strongdm.models

View Source
# Copyright 2020 StrongDM Inc
# 
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# 
#     http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# 

# This file was generated by protogen. DO NOT EDIT.

import collections
class AKS:
    """

    :param certificate_authority: 
    :param client_certificate: 
    :param client_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'client_certificate',
        'client_key',
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AKS ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'client_key: ' + repr(self.client_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class AKSBasicAuth:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.AKSBasicAuth ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class AKSServiceAccount:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param token: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
        'token',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
    def __repr__(self):
        return '<sdm.AKSServiceAccount ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )
class AKSServiceAccountUserImpersonation:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param token: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
        'token',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
    def __repr__(self):
        return '<sdm.AKSServiceAccountUserImpersonation ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )
class AKSUserImpersonation:
    """

    :param certificate_authority: 
    :param client_certificate: 
    :param client_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'client_certificate',
        'client_key',
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AKSUserImpersonation ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'client_key: ' + repr(self.client_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class AWS:
    """

    :param access_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_region: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'egress_filter',
        'healthcheck_region',
        'healthy',
        'id',
        'name',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        egress_filter=None,
        healthcheck_region=None,
        healthy=None,
        id=None,
        name=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.healthcheck_region = healthcheck_region
        self.healthy = healthy
        self.id = id
        self.name = name
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AWS ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'healthcheck_region': self.healthcheck_region,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_region=d.get('healthcheck_region'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class AWSStore:
    """

    :param id: Unique identifier of the SecretStore.
    :param name: Unique human-readable name of the SecretStore.
    :param region: 
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'id',
        'name',
        'region',
        'tags',
    ]
    def __init__(self,
        id=None,
        name=None,
        region=None,
        tags=None,
    ):
        self.id = id
        self.name = name
        self.region = region
        self.tags = tags
    def __repr__(self):
        return '<sdm.AWSStore ' + \
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'region': self.region,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            region=d.get('region'),
            tags=d.get('tags'),
        )
class AccountAttachment:
    """AccountAttachments assign an account to a role or composite role.

    :param account_id: The id of the account of this AccountAttachment.
    :param id: Unique identifier of the AccountAttachment.
    :param role_id: The id of the attached role of this AccountAttachment.
    """
    __slots__ = [
        'account_id',
        'id',
        'role_id',
    ]
    def __init__(self,
        account_id=None,
        id=None,
        role_id=None,
    ):
        self.account_id = account_id
        self.id = id
        self.role_id = role_id
    def __repr__(self):
        return '<sdm.AccountAttachment ' + \
            'account_id: ' + repr(self.account_id) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'role_id: ' + repr(self.role_id) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_id': self.account_id,
            'id': self.id,
            'role_id': self.role_id,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_id=d.get('account_id'),
            id=d.get('id'),
            role_id=d.get('role_id'),
        )
class AccountAttachmentCreateResponse:
    """AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

    :param account_attachment: The created AccountAttachment.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account_attachment',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account_attachment=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_attachment = account_attachment
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountAttachmentCreateResponse ' + \
            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_attachment': self.account_attachment,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_attachment=d.get('account_attachment'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class AccountAttachmentDeleteResponse:
    """AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountAttachmentDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class AccountAttachmentGetResponse:
    """AccountAttachmentGetResponse returns a requested AccountAttachment.

    :param account_attachment: The requested AccountAttachment.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account_attachment',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account_attachment=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_attachment = account_attachment
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountAttachmentGetResponse ' + \
            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_attachment': self.account_attachment,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_attachment=d.get('account_attachment'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class AccountCreateResponse:
    """AccountCreateResponse reports how the Accounts were created in the system.

    :param account: The created Account.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param token: The auth token generated for the Account. The Account will use this token to
 authenticate with the strongDM API.
    """
    __slots__ = [
        'account',
        'meta',
        'rate_limit',
        'token',
    ]
    def __init__(self,
        account=None,
        meta=None,
        rate_limit=None,
        token=None,
    ):
        self.account = account
        self.meta = meta
        self.rate_limit = rate_limit
        self.token = token
    def __repr__(self):
        return '<sdm.AccountCreateResponse ' + \
            'account: ' + repr(self.account) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account': self.account,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account=d.get('account'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            token=d.get('token'),
        )
class AccountDeleteResponse:
    """AccountDeleteResponse returns information about a Account that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class AccountGetResponse:
    """AccountGetResponse returns a requested Account.

    :param account: The requested Account.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account=None,
        meta=None,
        rate_limit=None,
    ):
        self.account = account
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountGetResponse ' + \
            'account: ' + repr(self.account) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account': self.account,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account=d.get('account'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class AccountGrant:
    """AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

    :param account_id: The id of the attached role of this AccountGrant.
    :param id: Unique identifier of the AccountGrant.
    :param resource_id: The id of the composite role of this AccountGrant.
    :param start_from: The timestamp when the resource will be granted. Optional. Both start_at
 and end_at must be defined together, or not defined at all.
    :param valid_until: The timestamp when the resource grant will expire. Optional. Both
 start_at and end_at must be defined together, or not defined at all.
    """
    __slots__ = [
        'account_id',
        'id',
        'resource_id',
        'start_from',
        'valid_until',
    ]
    def __init__(self,
        account_id=None,
        id=None,
        resource_id=None,
        start_from=None,
        valid_until=None,
    ):
        self.account_id = account_id
        self.id = id
        self.resource_id = resource_id
        self.start_from = start_from
        self.valid_until = valid_until
    def __repr__(self):
        return '<sdm.AccountGrant ' + \
            'account_id: ' + repr(self.account_id) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'resource_id: ' + repr(self.resource_id) + ' ' +\
            'start_from: ' + repr(self.start_from) + ' ' +\
            'valid_until: ' + repr(self.valid_until) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_id': self.account_id,
            'id': self.id,
            'resource_id': self.resource_id,
            'start_from': self.start_from,
            'valid_until': self.valid_until,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_id=d.get('account_id'),
            id=d.get('id'),
            resource_id=d.get('resource_id'),
            start_from=d.get('start_from'),
            valid_until=d.get('valid_until'),
        )
class AccountGrantCreateResponse:
    """AccountGrantCreateResponse reports how the AccountGrants were created in the system.

    :param account_grant: The created AccountGrant.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account_grant',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account_grant=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_grant = account_grant
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountGrantCreateResponse ' + \
            'account_grant: ' + repr(self.account_grant) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_grant': self.account_grant,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_grant=d.get('account_grant'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class AccountGrantDeleteResponse:
    """AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountGrantDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class AccountGrantGetResponse:
    """AccountGrantGetResponse returns a requested AccountGrant.

    :param account_grant: The requested AccountGrant.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account_grant',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account_grant=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_grant = account_grant
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountGrantGetResponse ' + \
            'account_grant: ' + repr(self.account_grant) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_grant': self.account_grant,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_grant=d.get('account_grant'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class AccountUpdateResponse:
    """AccountUpdateResponse returns the fields of a Account after it has been updated by
 a AccountUpdateRequest.

    :param account: The updated Account.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account=None,
        meta=None,
        rate_limit=None,
    ):
        self.account = account
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountUpdateResponse ' + \
            'account: ' + repr(self.account) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account': self.account,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account=d.get('account'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class AmazonEKS:
    """

    :param access_key: 
    :param certificate_authority: 
    :param cluster_name: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'certificate_authority',
        'cluster_name',
        'egress_filter',
        'endpoint',
        'healthcheck_namespace',
        'healthy',
        'id',
        'name',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        certificate_authority=None,
        cluster_name=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.certificate_authority = certificate_authority
        self.cluster_name = cluster_name
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AmazonEKS ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'certificate_authority': self.certificate_authority,
            'cluster_name': self.cluster_name,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            certificate_authority=d.get('certificate_authority'),
            cluster_name=d.get('cluster_name'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class AmazonEKSUserImpersonation:
    """

    :param access_key: 
    :param certificate_authority: 
    :param cluster_name: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'certificate_authority',
        'cluster_name',
        'egress_filter',
        'endpoint',
        'healthcheck_namespace',
        'healthy',
        'id',
        'name',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        certificate_authority=None,
        cluster_name=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.certificate_authority = certificate_authority
        self.cluster_name = cluster_name
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AmazonEKSUserImpersonation ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'certificate_authority': self.certificate_authority,
            'cluster_name': self.cluster_name,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            certificate_authority=d.get('certificate_authority'),
            cluster_name=d.get('cluster_name'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class AmazonES:
    """

    :param access_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port_override: 
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'egress_filter',
        'endpoint',
        'healthy',
        'id',
        'name',
        'port_override',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AmazonES ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class AmazonMQAMQP091:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.AmazonMQAMQP091 ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class Athena:
    """

    :param access_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param output: 
    :param port_override: 
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'egress_filter',
        'healthy',
        'id',
        'name',
        'output',
        'port_override',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        egress_filter=None,
        healthy=None,
        id=None,
        name=None,
        output=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.name = name
        self.output = output
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.Athena ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'output: ' + repr(self.output) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'output': self.output,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            output=d.get('output'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class AuroraMysql:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.AuroraMysql ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class AuroraPostgres:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.AuroraPostgres ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Azure:
    """

    :param app_id: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tenant_id: 
    """
    __slots__ = [
        'app_id',
        'egress_filter',
        'healthy',
        'id',
        'name',
        'password',
        'secret_store_id',
        'tags',
        'tenant_id',
    ]
    def __init__(self,
        app_id=None,
        egress_filter=None,
        healthy=None,
        id=None,
        name=None,
        password=None,
        secret_store_id=None,
        tags=None,
        tenant_id=None,
    ):
        self.app_id = app_id
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.name = name
        self.password = password
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tenant_id = tenant_id
    def __repr__(self):
        return '<sdm.Azure ' + \
            'app_id: ' + repr(self.app_id) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'app_id': self.app_id,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tenant_id': self.tenant_id,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            app_id=d.get('app_id'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tenant_id=d.get('tenant_id'),
        )
class AzureCertificate:
    """

    :param app_id: 
    :param client_certificate: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tenant_id: 
    """
    __slots__ = [
        'app_id',
        'client_certificate',
        'egress_filter',
        'healthy',
        'id',
        'name',
        'secret_store_id',
        'tags',
        'tenant_id',
    ]
    def __init__(self,
        app_id=None,
        client_certificate=None,
        egress_filter=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        tags=None,
        tenant_id=None,
    ):
        self.app_id = app_id
        self.client_certificate = client_certificate
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tenant_id = tenant_id
    def __repr__(self):
        return '<sdm.AzureCertificate ' + \
            'app_id: ' + repr(self.app_id) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'app_id': self.app_id,
            'client_certificate': self.client_certificate,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tenant_id': self.tenant_id,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            app_id=d.get('app_id'),
            client_certificate=d.get('client_certificate'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tenant_id=d.get('tenant_id'),
        )
class AzurePostgres:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.AzurePostgres ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class AzureStore:
    """

    :param id: Unique identifier of the SecretStore.
    :param name: Unique human-readable name of the SecretStore.
    :param tags: Tags is a map of key, value pairs.
    :param vault_uri: 
    """
    __slots__ = [
        'id',
        'name',
        'tags',
        'vault_uri',
    ]
    def __init__(self,
        id=None,
        name=None,
        tags=None,
        vault_uri=None,
    ):
        self.id = id
        self.name = name
        self.tags = tags
        self.vault_uri = vault_uri
    def __repr__(self):
        return '<sdm.AzureStore ' + \
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'tags': self.tags,
            'vault_uri': self.vault_uri,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            tags=d.get('tags'),
            vault_uri=d.get('vault_uri'),
        )
class BigQuery:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port_override: 
    :param private_key: 
    :param project: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'endpoint',
        'healthy',
        'id',
        'name',
        'port_override',
        'private_key',
        'project',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port_override=None,
        private_key=None,
        project=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port_override = port_override
        self.private_key = private_key
        self.project = project
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.BigQuery ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'private_key: ' + repr(self.private_key) + ' ' +\
            'project: ' + repr(self.project) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port_override': self.port_override,
            'private_key': self.private_key,
            'project': self.project,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port_override=d.get('port_override'),
            private_key=d.get('private_key'),
            project=d.get('project'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Cassandra:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.Cassandra ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class Citus:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Citus ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Clustrix:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Clustrix ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Cockroach:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Cockroach ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class ControlPanelGetSSHCAPublicKeyResponse:
    """ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 organization's SSH Certificate Authority public key.

    :param meta: Reserved for future use.
    :param public_key: The public key of the SSH Certificate Authority, in OpenSSH RSA public
 key format.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'public_key',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        public_key=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.public_key = public_key
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'public_key: ' + repr(self.public_key) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'public_key': self.public_key,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            public_key=d.get('public_key'),
            rate_limit=d.get('rate_limit'),
        )
class ControlPanelVerifyJWTResponse:
    """ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param valid: Reports if the given token is valid.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'valid',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        valid=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.valid = valid
    def __repr__(self):
        return '<sdm.ControlPanelVerifyJWTResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'valid: ' + repr(self.valid) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'valid': self.valid,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            valid=d.get('valid'),
        )
class CreateResponseMetadata:
    """CreateResponseMetadata is reserved for future use."""
    __slots__ = [
    ]
    def __init__(self,
    ):
        pass
    def __repr__(self):
        return '<sdm.CreateResponseMetadata ' + \
            '>'
    def to_dict(self):
        return {
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
        )
class DB2I:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.DB2I ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class DB2LUW:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.DB2LUW ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class DeleteResponseMetadata:
    """DeleteResponseMetadata is reserved for future use."""
    __slots__ = [
    ]
    def __init__(self,
    ):
        pass
    def __repr__(self):
        return '<sdm.DeleteResponseMetadata ' + \
            '>'
    def to_dict(self):
        return {
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
        )
class DocumentDBHost:
    """

    :param auth_database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.DocumentDBHost ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class DocumentDBReplicaSet:
    """

    :param auth_database: 
    :param connect_to_replica: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port_override: 
    :param replica_set: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'connect_to_replica',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port_override',
        'replica_set',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        connect_to_replica=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.connect_to_replica = connect_to_replica
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.DocumentDBReplicaSet ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'replica_set: ' + repr(self.replica_set) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'connect_to_replica': self.connect_to_replica,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            connect_to_replica=d.get('connect_to_replica'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Druid:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Druid ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class DynamoDB:
    """

    :param access_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port_override: 
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'egress_filter',
        'endpoint',
        'healthy',
        'id',
        'name',
        'port_override',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.DynamoDB ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class Elastic:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.Elastic ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class ElasticacheRedis:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
    def __repr__(self):
        return '<sdm.ElasticacheRedis ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
        )
class GCP:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param keyfile: 
    :param name: Unique human-readable name of the Resource.
    :param scopes: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'id',
        'keyfile',
        'name',
        'scopes',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        id=None,
        keyfile=None,
        name=None,
        scopes=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.keyfile = keyfile
        self.name = name
        self.scopes = scopes
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.GCP ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'keyfile: ' + repr(self.keyfile) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'scopes: ' + repr(self.scopes) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'keyfile': self.keyfile,
            'name': self.name,
            'scopes': self.scopes,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            keyfile=d.get('keyfile'),
            name=d.get('name'),
            scopes=d.get('scopes'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class Gateway:
    """Gateway represents a StrongDM CLI installation running in gateway mode.

    :param bind_address: The hostname/port tuple which the gateway daemon will bind to.
 If not provided on create, set to "0.0.0.0:<listen_address_port>".
    :param gateway_filter: GatewayFilter can be used to restrict the peering between relays and
 gateways.
    :param id: Unique identifier of the Gateway.
    :param listen_address: The public hostname/port tuple at which the gateway will be accessible to clients.
    :param name: Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
    :param state: The current state of the gateway. One of: "new", "verifying_restart",
 "restarting", "started", "stopped", "dead", "unknown"
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'bind_address',
        'gateway_filter',
        'id',
        'listen_address',
        'name',
        'state',
        'tags',
    ]
    def __init__(self,
        bind_address=None,
        gateway_filter=None,
        id=None,
        listen_address=None,
        name=None,
        state=None,
        tags=None,
    ):
        self.bind_address = bind_address
        self.gateway_filter = gateway_filter
        self.id = id
        self.listen_address = listen_address
        self.name = name
        self.state = state
        self.tags = tags
    def __repr__(self):
        return '<sdm.Gateway ' + \
            'bind_address: ' + repr(self.bind_address) + ' ' +\
            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'listen_address: ' + repr(self.listen_address) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'state: ' + repr(self.state) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'bind_address': self.bind_address,
            'gateway_filter': self.gateway_filter,
            'id': self.id,
            'listen_address': self.listen_address,
            'name': self.name,
            'state': self.state,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            bind_address=d.get('bind_address'),
            gateway_filter=d.get('gateway_filter'),
            id=d.get('id'),
            listen_address=d.get('listen_address'),
            name=d.get('name'),
            state=d.get('state'),
            tags=d.get('tags'),
        )
class GetResponseMetadata:
    """GetResponseMetadata is reserved for future use."""
    __slots__ = [
    ]
    def __init__(self,
    ):
        pass
    def __repr__(self):
        return '<sdm.GetResponseMetadata ' + \
            '>'
    def to_dict(self):
        return {
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
        )
class GoogleGKE:
    """

    :param certificate_authority: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param service_account_key: 
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'egress_filter',
        'endpoint',
        'healthcheck_namespace',
        'healthy',
        'id',
        'name',
        'secret_store_id',
        'service_account_key',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        service_account_key=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.service_account_key = service_account_key
        self.tags = tags
    def __repr__(self):
        return '<sdm.GoogleGKE ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'service_account_key': self.service_account_key,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            service_account_key=d.get('service_account_key'),
            tags=d.get('tags'),
        )
class GoogleGKEUserImpersonation:
    """

    :param certificate_authority: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param service_account_key: 
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'egress_filter',
        'endpoint',
        'healthcheck_namespace',
        'healthy',
        'id',
        'name',
        'secret_store_id',
        'service_account_key',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        service_account_key=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.service_account_key = service_account_key
        self.tags = tags
    def __repr__(self):
        return '<sdm.GoogleGKEUserImpersonation ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'service_account_key': self.service_account_key,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            service_account_key=d.get('service_account_key'),
            tags=d.get('tags'),
        )
class Greenplum:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Greenplum ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class HTTPAuth:
    """

    :param auth_header: 
    :param default_path: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param headers_blacklist: 
    :param healthcheck_path: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param subdomain: 
    :param tags: Tags is a map of key, value pairs.
    :param url: 
    """
    __slots__ = [
        'auth_header',
        'default_path',
        'egress_filter',
        'headers_blacklist',
        'healthcheck_path',
        'healthy',
        'id',
        'name',
        'secret_store_id',
        'subdomain',
        'tags',
        'url',
    ]
    def __init__(self,
        auth_header=None,
        default_path=None,
        egress_filter=None,
        headers_blacklist=None,
        healthcheck_path=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        subdomain=None,
        tags=None,
        url=None,
    ):
        self.auth_header = auth_header
        self.default_path = default_path
        self.egress_filter = egress_filter
        self.headers_blacklist = headers_blacklist
        self.healthcheck_path = healthcheck_path
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.subdomain = subdomain
        self.tags = tags
        self.url = url
    def __repr__(self):
        return '<sdm.HTTPAuth ' + \
            'auth_header: ' + repr(self.auth_header) + ' ' +\
            'default_path: ' + repr(self.default_path) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'subdomain: ' + repr(self.subdomain) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'url: ' + repr(self.url) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_header': self.auth_header,
            'default_path': self.default_path,
            'egress_filter': self.egress_filter,
            'headers_blacklist': self.headers_blacklist,
            'healthcheck_path': self.healthcheck_path,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'subdomain': self.subdomain,
            'tags': self.tags,
            'url': self.url,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_header=d.get('auth_header'),
            default_path=d.get('default_path'),
            egress_filter=d.get('egress_filter'),
            headers_blacklist=d.get('headers_blacklist'),
            healthcheck_path=d.get('healthcheck_path'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            subdomain=d.get('subdomain'),
            tags=d.get('tags'),
            url=d.get('url'),
        )
class HTTPBasicAuth:
    """

    :param default_path: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param headers_blacklist: 
    :param healthcheck_path: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param subdomain: 
    :param tags: Tags is a map of key, value pairs.
    :param url: 
    :param username: 
    """
    __slots__ = [
        'default_path',
        'egress_filter',
        'headers_blacklist',
        'healthcheck_path',
        'healthy',
        'id',
        'name',
        'password',
        'secret_store_id',
        'subdomain',
        'tags',
        'url',
        'username',
    ]
    def __init__(self,
        default_path=None,
        egress_filter=None,
        headers_blacklist=None,
        healthcheck_path=None,
        healthy=None,
        id=None,
        name=None,
        password=None,
        secret_store_id=None,
        subdomain=None,
        tags=None,
        url=None,
        username=None,
    ):
        self.default_path = default_path
        self.egress_filter = egress_filter
        self.headers_blacklist = headers_blacklist
        self.healthcheck_path = healthcheck_path
        self.healthy = healthy
        self.id = id
        self.name = name
        self.password = password
        self.secret_store_id = secret_store_id
        self.subdomain = subdomain
        self.tags = tags
        self.url = url
        self.username = username
    def __repr__(self):
        return '<sdm.HTTPBasicAuth ' + \
            'default_path: ' + repr(self.default_path) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'subdomain: ' + repr(self.subdomain) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'url: ' + repr(self.url) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'default_path': self.default_path,
            'egress_filter': self.egress_filter,
            'headers_blacklist': self.headers_blacklist,
            'healthcheck_path': self.healthcheck_path,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'secret_store_id': self.secret_store_id,
            'subdomain': self.subdomain,
            'tags': self.tags,
            'url': self.url,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            default_path=d.get('default_path'),
            egress_filter=d.get('egress_filter'),
            headers_blacklist=d.get('headers_blacklist'),
            healthcheck_path=d.get('healthcheck_path'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            secret_store_id=d.get('secret_store_id'),
            subdomain=d.get('subdomain'),
            tags=d.get('tags'),
            url=d.get('url'),
            username=d.get('username'),
        )
class HTTPNoAuth:
    """

    :param default_path: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param headers_blacklist: 
    :param healthcheck_path: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param subdomain: 
    :param tags: Tags is a map of key, value pairs.
    :param url: 
    """
    __slots__ = [
        'default_path',
        'egress_filter',
        'headers_blacklist',
        'healthcheck_path',
        'healthy',
        'id',
        'name',
        'secret_store_id',
        'subdomain',
        'tags',
        'url',
    ]
    def __init__(self,
        default_path=None,
        egress_filter=None,
        headers_blacklist=None,
        healthcheck_path=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        subdomain=None,
        tags=None,
        url=None,
    ):
        self.default_path = default_path
        self.egress_filter = egress_filter
        self.headers_blacklist = headers_blacklist
        self.healthcheck_path = healthcheck_path
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.subdomain = subdomain
        self.tags = tags
        self.url = url
    def __repr__(self):
        return '<sdm.HTTPNoAuth ' + \
            'default_path: ' + repr(self.default_path) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'subdomain: ' + repr(self.subdomain) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'url: ' + repr(self.url) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'default_path': self.default_path,
            'egress_filter': self.egress_filter,
            'headers_blacklist': self.headers_blacklist,
            'healthcheck_path': self.healthcheck_path,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'subdomain': self.subdomain,
            'tags': self.tags,
            'url': self.url,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            default_path=d.get('default_path'),
            egress_filter=d.get('egress_filter'),
            headers_blacklist=d.get('headers_blacklist'),
            healthcheck_path=d.get('healthcheck_path'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            subdomain=d.get('subdomain'),
            tags=d.get('tags'),
            url=d.get('url'),
        )
class Kubernetes:
    """

    :param certificate_authority: 
    :param client_certificate: 
    :param client_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'client_certificate',
        'client_key',
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.Kubernetes ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'client_key: ' + repr(self.client_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class KubernetesBasicAuth:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.KubernetesBasicAuth ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class KubernetesServiceAccount:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param token: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
        'token',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
    def __repr__(self):
        return '<sdm.KubernetesServiceAccount ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )
class KubernetesServiceAccountUserImpersonation:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param token: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
        'token',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
    def __repr__(self):
        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )
class KubernetesUserImpersonation:
    """

    :param certificate_authority: 
    :param client_certificate: 
    :param client_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'client_certificate',
        'client_key',
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.KubernetesUserImpersonation ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'client_key: ' + repr(self.client_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class MTLSPostgres:
    """

    :param certificate_authority: 
    :param client_certificate: 
    :param client_key: 
    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param server_name: 
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'certificate_authority',
        'client_certificate',
        'client_key',
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'server_name',
        'tags',
        'username',
    ]
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        server_name=None,
        tags=None,
        username=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.server_name = server_name
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.MTLSPostgres ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'client_key: ' + repr(self.client_key) + ' ' +\
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'server_name: ' + repr(self.server_name) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'server_name': self.server_name,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            server_name=d.get('server_name'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Maria:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Maria ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Memcached:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.Memcached ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class Memsql:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Memsql ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class MongoHost:
    """

    :param auth_database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.MongoHost ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class MongoLegacyHost:
    """

    :param auth_database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param replica_set: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'replica_set',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.MongoLegacyHost ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'replica_set: ' + repr(self.replica_set) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class MongoLegacyReplicaset:
    """

    :param auth_database: 
    :param connect_to_replica: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param replica_set: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'connect_to_replica',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'replica_set',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        connect_to_replica=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.connect_to_replica = connect_to_replica
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.MongoLegacyReplicaset ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'replica_set: ' + repr(self.replica_set) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'connect_to_replica': self.connect_to_replica,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            connect_to_replica=d.get('connect_to_replica'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class MongoReplicaSet:
    """

    :param auth_database: 
    :param connect_to_replica: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param replica_set: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'connect_to_replica',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'replica_set',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        connect_to_replica=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.connect_to_replica = connect_to_replica
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.MongoReplicaSet ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'replica_set: ' + repr(self.replica_set) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'connect_to_replica': self.connect_to_replica,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            connect_to_replica=d.get('connect_to_replica'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class MongoShardedCluster:
    """

    :param auth_database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.MongoShardedCluster ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class Mysql:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Mysql ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Neptune:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'egress_filter',
        'endpoint',
        'healthy',
        'id',
        'name',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.Neptune ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class NeptuneIAM:
    """

    :param access_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_override: 
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'egress_filter',
        'endpoint',
        'healthy',
        'id',
        'name',
        'port',
        'port_override',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.NeptuneIAM ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class NodeCreateResponse:
    """NodeCreateResponse reports how the Nodes were created in the system.

    :param meta: Reserved for future use.
    :param node: The created Node.
    :param rate_limit: Rate limit information.
    :param token: The auth token generated for the Node. The Node will use this token to
 authenticate with the strongDM API.
    """
    __slots__ = [
        'meta',
        'node',
        'rate_limit',
        'token',
    ]
    def __init__(self,
        meta=None,
        node=None,
        rate_limit=None,
        token=None,
    ):
        self.meta = meta
        self.node = node
        self.rate_limit = rate_limit
        self.token = token
    def __repr__(self):
        return '<sdm.NodeCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'node: ' + repr(self.node) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'node': self.node,
            'rate_limit': self.rate_limit,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            node=d.get('node'),
            rate_limit=d.get('rate_limit'),
            token=d.get('token'),
        )
class NodeDeleteResponse:
    """NodeDeleteResponse returns information about a Node that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.NodeDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class NodeGetResponse:
    """NodeGetResponse returns a requested Node.

    :param meta: Reserved for future use.
    :param node: The requested Node.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'node',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        node=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.node = node
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.NodeGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'node: ' + repr(self.node) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'node': self.node,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            node=d.get('node'),
            rate_limit=d.get('rate_limit'),
        )
class NodeUpdateResponse:
    """NodeUpdateResponse returns the fields of a Node after it has been updated by
 a NodeUpdateRequest.

    :param meta: Reserved for future use.
    :param node: The updated Node.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'node',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        node=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.node = node
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.NodeUpdateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'node: ' + repr(self.node) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'node': self.node,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            node=d.get('node'),
            rate_limit=d.get('rate_limit'),
        )
class Oracle:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.Oracle ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class Postgres:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Postgres ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Presto:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.Presto ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class RDP:
    """

    :param downgrade_nla_connections: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'downgrade_nla_connections',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        downgrade_nla_connections=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.downgrade_nla_connections = downgrade_nla_connections
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.RDP ' + \
            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'downgrade_nla_connections': self.downgrade_nla_connections,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            downgrade_nla_connections=d.get('downgrade_nla_connections'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class RabbitMQAMQP091:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.RabbitMQAMQP091 ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
class RateLimitMetadata:
    """RateLimitMetadata contains information about remaining requests avaialable
 to the user over some timeframe.

    :param bucket: The bucket this user/token is associated with, which may be shared between
 multiple users/tokens.
    :param limit: How many total requests the user/token is authorized to make before being
 rate limited.
    :param remaining: How many remaining requests out of the limit are still avaialable.
    :param reset_at: The time when remaining will be reset to limit.
    """
    __slots__ = [
        'bucket',
        'limit',
        'remaining',
        'reset_at',
    ]
    def __init__(self,
        bucket=None,
        limit=None,
        remaining=None,
        reset_at=None,
    ):
        self.bucket = bucket
        self.limit = limit
        self.remaining = remaining
        self.reset_at = reset_at
    def __repr__(self):
        return '<sdm.RateLimitMetadata ' + \
            'bucket: ' + repr(self.bucket) + ' ' +\
            'limit: ' + repr(self.limit) + ' ' +\
            'remaining: ' + repr(self.remaining) + ' ' +\
            'reset_at: ' + repr(self.reset_at) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'bucket': self.bucket,
            'limit': self.limit,
            'remaining': self.remaining,
            'reset_at': self.reset_at,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            bucket=d.get('bucket'),
            limit=d.get('limit'),
            remaining=d.get('remaining'),
            reset_at=d.get('reset_at'),
        )
class RawTCP:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.RawTCP ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class Redis:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.Redis ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
class Redshift:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Redshift ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Relay:
    """Relay represents a StrongDM CLI installation running in relay mode.

    :param gateway_filter: GatewayFilter can be used to restrict the peering between relays and
 gateways.
    :param id: Unique identifier of the Relay.
    :param name: Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
    :param state: The current state of the relay. One of: "new", "verifying_restart",
 "awaiting_restart", "restarting", "started", "stopped", "dead",
 "unknown".
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'gateway_filter',
        'id',
        'name',
        'state',
        'tags',
    ]
    def __init__(self,
        gateway_filter=None,
        id=None,
        name=None,
        state=None,
        tags=None,
    ):
        self.gateway_filter = gateway_filter
        self.id = id
        self.name = name
        self.state = state
        self.tags = tags
    def __repr__(self):
        return '<sdm.Relay ' + \
            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'state: ' + repr(self.state) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'gateway_filter': self.gateway_filter,
            'id': self.id,
            'name': self.name,
            'state': self.state,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            gateway_filter=d.get('gateway_filter'),
            id=d.get('id'),
            name=d.get('name'),
            state=d.get('state'),
            tags=d.get('tags'),
        )
class ResourceCreateResponse:
    """ResourceCreateResponse reports how the Resources were created in the system.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param resource: The created Resource.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'resource',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        resource=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.resource = resource
    def __repr__(self):
        return '<sdm.ResourceCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'resource: ' + repr(self.resource) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'resource': self.resource,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            resource=d.get('resource'),
        )
class ResourceDeleteResponse:
    """ResourceDeleteResponse returns information about a Resource that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.ResourceDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class ResourceGetResponse:
    """ResourceGetResponse returns a requested Resource.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param resource: The requested Resource.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'resource',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        resource=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.resource = resource
    def __repr__(self):
        return '<sdm.ResourceGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'resource: ' + repr(self.resource) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'resource': self.resource,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            resource=d.get('resource'),
        )
class ResourceUpdateResponse:
    """ResourceUpdateResponse returns the fields of a Resource after it has been updated by
 a ResourceUpdateRequest.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param resource: The updated Resource.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'resource',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        resource=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.resource = resource
    def __repr__(self):
        return '<sdm.ResourceUpdateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'resource: ' + repr(self.resource) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'resource': self.resource,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            resource=d.get('resource'),
        )
class Role:
    """A Role is a collection of access grants, and typically corresponds to a team, Active Directory OU, or other organizational unit. Users are granted access to resources by assigning them to roles.

    :param access_rules: AccessRules is a list of access rules defining the resources this Role has access to.
    :param composite: Composite is true if the Role is a composite role.

 Deprecated: composite roles are deprecated, use multi-role instead.
    :param id: Unique identifier of the Role.
    :param name: Unique human-readable name of the Role.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_rules',
        'composite',
        'id',
        'name',
        'tags',
    ]
    def __init__(self,
        access_rules=None,
        composite=None,
        id=None,
        name=None,
        tags=None,
    ):
        self.access_rules = access_rules
        self.composite = composite
        self.id = id
        self.name = name
        self.tags = tags
    def __repr__(self):
        return '<sdm.Role ' + \
            'access_rules: ' + repr(self.access_rules) + ' ' +\
            'composite: ' + repr(self.composite) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_rules': self.access_rules,
            'composite': self.composite,
            'id': self.id,
            'name': self.name,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_rules=d.get('access_rules'),
            composite=d.get('composite'),
            id=d.get('id'),
            name=d.get('name'),
            tags=d.get('tags'),
        )
class RoleAttachment:
    """A RoleAttachment assigns a role to a composite role.
 
 Deprecated: use multi-role instead.

    :param attached_role_id: The id of the attached role of this RoleAttachment.
    :param composite_role_id: The id of the composite role of this RoleAttachment.
    :param id: Unique identifier of the RoleAttachment.
    """
    __slots__ = [
        'attached_role_id',
        'composite_role_id',
        'id',
    ]
    def __init__(self,
        attached_role_id=None,
        composite_role_id=None,
        id=None,
    ):
        self.attached_role_id = attached_role_id
        self.composite_role_id = composite_role_id
        self.id = id
    def __repr__(self):
        return '<sdm.RoleAttachment ' + \
            'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\
            'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'attached_role_id': self.attached_role_id,
            'composite_role_id': self.composite_role_id,
            'id': self.id,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            attached_role_id=d.get('attached_role_id'),
            composite_role_id=d.get('composite_role_id'),
            id=d.get('id'),
        )
class RoleAttachmentCreateResponse:
    """RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.
 
 Deprecated: use multi-role instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role_attachment: The created RoleAttachment.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role_attachment',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_attachment=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_attachment = role_attachment
    def __repr__(self):
        return '<sdm.RoleAttachmentCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_attachment': self.role_attachment,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_attachment=d.get('role_attachment'),
        )
class RoleAttachmentDeleteResponse:
    """RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.
 
 Deprecated: use multi-role instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.RoleAttachmentDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class RoleAttachmentGetResponse:
    """RoleAttachmentGetResponse returns a requested RoleAttachment.
 
 Deprecated: use multi-role instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role_attachment: The requested RoleAttachment.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role_attachment',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_attachment=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_attachment = role_attachment
    def __repr__(self):
        return '<sdm.RoleAttachmentGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_attachment': self.role_attachment,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_attachment=d.get('role_attachment'),
        )
class RoleCreateResponse:
    """RoleCreateResponse reports how the Roles were created in the system. It can
 communicate partial successes or failures.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role: The created Role.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role = role
    def __repr__(self):
        return '<sdm.RoleCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role: ' + repr(self.role) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role': self.role,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role=d.get('role'),
        )
class RoleDeleteResponse:
    """RoleDeleteResponse returns information about a Role that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.RoleDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class RoleGetResponse:
    """RoleGetResponse returns a requested Role.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role: The requested Role.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role = role
    def __repr__(self):
        return '<sdm.RoleGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role: ' + repr(self.role) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role': self.role,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role=d.get('role'),
        )
class RoleGrant:
    """A RoleGrant connects a resource to a role, granting members of the role access to that resource.

 Deprecated: use access rules instead.

    :param id: Unique identifier of the RoleGrant.
    :param resource_id: The id of the resource of this RoleGrant.
    :param role_id: The id of the attached role of this RoleGrant.
    """
    __slots__ = [
        'id',
        'resource_id',
        'role_id',
    ]
    def __init__(self,
        id=None,
        resource_id=None,
        role_id=None,
    ):
        self.id = id
        self.resource_id = resource_id
        self.role_id = role_id
    def __repr__(self):
        return '<sdm.RoleGrant ' + \
            'id: ' + repr(self.id) + ' ' +\
            'resource_id: ' + repr(self.resource_id) + ' ' +\
            'role_id: ' + repr(self.role_id) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'id': self.id,
            'resource_id': self.resource_id,
            'role_id': self.role_id,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            resource_id=d.get('resource_id'),
            role_id=d.get('role_id'),
        )
class RoleGrantCreateResponse:
    """RoleGrantCreateResponse reports how the RoleGrants were created in the system.

 Deprecated: use access rules instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role_grant: The created RoleGrant.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role_grant',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_grant=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_grant = role_grant
    def __repr__(self):
        return '<sdm.RoleGrantCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role_grant: ' + repr(self.role_grant) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_grant': self.role_grant,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_grant=d.get('role_grant'),
        )
class RoleGrantDeleteResponse:
    """RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.

 Deprecated: use access rules instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.RoleGrantDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class RoleGrantGetResponse:
    """RoleGrantGetResponse returns a requested RoleGrant.

 Deprecated: use access rules instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role_grant: The requested RoleGrant.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role_grant',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_grant=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_grant = role_grant
    def __repr__(self):
        return '<sdm.RoleGrantGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role_grant: ' + repr(self.role_grant) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_grant': self.role_grant,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_grant=d.get('role_grant'),
        )
class RoleUpdateResponse:
    """RoleUpdateResponse returns the fields of a Role after it has been updated by
 a RoleUpdateRequest.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role: The updated Role.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role = role
    def __repr__(self):
        return '<sdm.RoleUpdateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role: ' + repr(self.role) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role': self.role,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role=d.get('role'),
        )
class SQLServer:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param schema: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'schema',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        schema=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.schema = schema
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SQLServer ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'schema: ' + repr(self.schema) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'schema': self.schema,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            schema=d.get('schema'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class SSH:
    """

    :param allow_deprecated_key_exchanges: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_forwarding: 
    :param public_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'allow_deprecated_key_exchanges',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'port_forwarding',
        'public_key',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        allow_deprecated_key_exchanges=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_forwarding=None,
        public_key=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_forwarding = port_forwarding
        self.public_key = public_key
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SSH ' + \
            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
            'public_key: ' + repr(self.public_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'allow_deprecated_key_exchanges': self.allow_deprecated_key_exchanges,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_forwarding': self.port_forwarding,
            'public_key': self.public_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            allow_deprecated_key_exchanges=d.get('allow_deprecated_key_exchanges'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_forwarding=d.get('port_forwarding'),
            public_key=d.get('public_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class SSHCert:
    """

    :param allow_deprecated_key_exchanges: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_forwarding: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'allow_deprecated_key_exchanges',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'port_forwarding',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        allow_deprecated_key_exchanges=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_forwarding=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_forwarding = port_forwarding
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SSHCert ' + \
            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'allow_deprecated_key_exchanges': self.allow_deprecated_key_exchanges,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_forwarding': self.port_forwarding,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            allow_deprecated_key_exchanges=d.get('allow_deprecated_key_exchanges'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_forwarding=d.get('port_forwarding'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class SSHCustomerKey:
    """

    :param allow_deprecated_key_exchanges: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_forwarding: 
    :param private_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'allow_deprecated_key_exchanges',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'port_forwarding',
        'private_key',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        allow_deprecated_key_exchanges=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_forwarding=None,
        private_key=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_forwarding = port_forwarding
        self.private_key = private_key
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SSHCustomerKey ' + \
            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
            'private_key: ' + repr(self.private_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'allow_deprecated_key_exchanges': self.allow_deprecated_key_exchanges,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_forwarding': self.port_forwarding,
            'private_key': self.private_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            allow_deprecated_key_exchanges=d.get('allow_deprecated_key_exchanges'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_forwarding=d.get('port_forwarding'),
            private_key=d.get('private_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class SecretStoreCreateResponse:
    """SecretStoreCreateResponse reports how the SecretStores were created in the system.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param secret_store: The created SecretStore.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'secret_store',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        secret_store=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.secret_store = secret_store
    def __repr__(self):
        return '<sdm.SecretStoreCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'secret_store: ' + repr(self.secret_store) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'secret_store': self.secret_store,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            secret_store=d.get('secret_store'),
        )
class SecretStoreDeleteResponse:
    """SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.SecretStoreDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
class SecretStoreGetResponse:
    """SecretStoreGetResponse returns a requested SecretStore.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param secret_store: The requested SecretStore.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'secret_store',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        secret_store=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.secret_store = secret_store
    def __repr__(self):
        return '<sdm.SecretStoreGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'secret_store: ' + repr(self.secret_store) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'secret_store': self.secret_store,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            secret_store=d.get('secret_store'),
        )
class SecretStoreUpdateResponse:
    """SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
 a SecretStoreUpdateRequest.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param secret_store: The updated SecretStore.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'secret_store',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        secret_store=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.secret_store = secret_store
    def __repr__(self):
        return '<sdm.SecretStoreUpdateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'secret_store: ' + repr(self.secret_store) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'secret_store': self.secret_store,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            secret_store=d.get('secret_store'),
        )
class Service:
    """A Service is a service account that can connect to resources they are granted
 directly, or granted via roles. Services are typically automated jobs.

    :param id: Unique identifier of the Service.
    :param name: Unique human-readable name of the Service.
    :param suspended: The Service's suspended state.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'id',
        'name',
        'suspended',
        'tags',
    ]
    def __init__(self,
        id=None,
        name=None,
        suspended=None,
        tags=None,
    ):
        self.id = id
        self.name = name
        self.suspended = suspended
        self.tags = tags
    def __repr__(self):
        return '<sdm.Service ' + \
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'suspended: ' + repr(self.suspended) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'suspended': self.suspended,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            suspended=d.get('suspended'),
            tags=d.get('tags'),
        )
class SingleStore:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SingleStore ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Snowflake:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port_override: 
    :param schema: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port_override',
        'schema',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port_override=None,
        schema=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port_override = port_override
        self.schema = schema
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Snowflake ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'schema: ' + repr(self.schema) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port_override': self.port_override,
            'schema': self.schema,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port_override=d.get('port_override'),
            schema=d.get('schema'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Sybase:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Sybase ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class SybaseIQ:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SybaseIQ ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class Tag:
    """

    :param name: 
    :param value: 
    """
    __slots__ = [
        'name',
        'value',
    ]
    def __init__(self,
        name=None,
        value=None,
    ):
        self.name = name
        self.value = value
    def __repr__(self):
        return '<sdm.Tag ' + \
            'name: ' + repr(self.name) + ' ' +\
            'value: ' + repr(self.value) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'name': self.name,
            'value': self.value,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            name=d.get('name'),
            value=d.get('value'),
        )
class Teradata:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Teradata ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
class UpdateResponseMetadata:
    """UpdateResponseMetadata is reserved for future use."""
    __slots__ = [
    ]
    def __init__(self,
    ):
        pass
    def __repr__(self):
        return '<sdm.UpdateResponseMetadata ' + \
            '>'
    def to_dict(self):
        return {
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
        )
class User:
    """A User can connect to resources they are granted directly, or granted
 via roles.

    :param email: The User's email address. Must be unique.
    :param first_name: The User's first name.
    :param id: Unique identifier of the User.
    :param last_name: The User's last name.
    :param suspended: The User's suspended state.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'email',
        'first_name',
        'id',
        'last_name',
        'suspended',
        'tags',
    ]
    def __init__(self,
        email=None,
        first_name=None,
        id=None,
        last_name=None,
        suspended=None,
        tags=None,
    ):
        self.email = email
        self.first_name = first_name
        self.id = id
        self.last_name = last_name
        self.suspended = suspended
        self.tags = tags
    def __repr__(self):
        return '<sdm.User ' + \
            'email: ' + repr(self.email) + ' ' +\
            'first_name: ' + repr(self.first_name) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'last_name: ' + repr(self.last_name) + ' ' +\
            'suspended: ' + repr(self.suspended) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'email': self.email,
            'first_name': self.first_name,
            'id': self.id,
            'last_name': self.last_name,
            'suspended': self.suspended,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            email=d.get('email'),
            first_name=d.get('first_name'),
            id=d.get('id'),
            last_name=d.get('last_name'),
            suspended=d.get('suspended'),
            tags=d.get('tags'),
        )
class VaultTLSStore:
    """

    :param ca_cert_path: 
    :param client_cert_path: 
    :param client_key_path: 
    :param id: Unique identifier of the SecretStore.
    :param name: Unique human-readable name of the SecretStore.
    :param namespace: 
    :param server_address: 
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'ca_cert_path',
        'client_cert_path',
        'client_key_path',
        'id',
        'name',
        'namespace',
        'server_address',
        'tags',
    ]
    def __init__(self,
        ca_cert_path=None,
        client_cert_path=None,
        client_key_path=None,
        id=None,
        name=None,
        namespace=None,
        server_address=None,
        tags=None,
    ):
        self.ca_cert_path = ca_cert_path
        self.client_cert_path = client_cert_path
        self.client_key_path = client_key_path
        self.id = id
        self.name = name
        self.namespace = namespace
        self.server_address = server_address
        self.tags = tags
    def __repr__(self):
        return '<sdm.VaultTLSStore ' + \
            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'namespace: ' + repr(self.namespace) + ' ' +\
            'server_address: ' + repr(self.server_address) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'ca_cert_path': self.ca_cert_path,
            'client_cert_path': self.client_cert_path,
            'client_key_path': self.client_key_path,
            'id': self.id,
            'name': self.name,
            'namespace': self.namespace,
            'server_address': self.server_address,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            ca_cert_path=d.get('ca_cert_path'),
            client_cert_path=d.get('client_cert_path'),
            client_key_path=d.get('client_key_path'),
            id=d.get('id'),
            name=d.get('name'),
            namespace=d.get('namespace'),
            server_address=d.get('server_address'),
            tags=d.get('tags'),
        )
class VaultTokenStore:
    """

    :param id: Unique identifier of the SecretStore.
    :param name: Unique human-readable name of the SecretStore.
    :param namespace: 
    :param server_address: 
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'id',
        'name',
        'namespace',
        'server_address',
        'tags',
    ]
    def __init__(self,
        id=None,
        name=None,
        namespace=None,
        server_address=None,
        tags=None,
    ):
        self.id = id
        self.name = name
        self.namespace = namespace
        self.server_address = server_address
        self.tags = tags
    def __repr__(self):
        return '<sdm.VaultTokenStore ' + \
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'namespace: ' + repr(self.namespace) + ' ' +\
            'server_address: ' + repr(self.server_address) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'namespace': self.namespace,
            'server_address': self.server_address,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            namespace=d.get('namespace'),
            server_address=d.get('server_address'),
            tags=d.get('tags'),
        )
#   class AKS:
View Source
class AKS:
    """

    :param certificate_authority: 
    :param client_certificate: 
    :param client_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'client_certificate',
        'client_key',
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AKS ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'client_key: ' + repr(self.client_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param certificate_authority: :param client_certificate: :param client_key: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   AKS( certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
#   certificate_authority
#   client_certificate
#   client_key
#   egress_filter
#   healthcheck_namespace
#   healthy
#   hostname
#   id
#   name
#   port
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class AKSBasicAuth:
View Source
class AKSBasicAuth:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.AKSBasicAuth ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   AKSBasicAuth( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   egress_filter
#   healthcheck_namespace
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class AKSServiceAccount:
View Source
class AKSServiceAccount:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param token: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
        'token',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
    def __repr__(self):
        return '<sdm.AKSServiceAccount ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param token:

#   AKSServiceAccount( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None, token=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
#   egress_filter
#   healthcheck_namespace
#   healthy
#   hostname
#   id
#   name
#   port
#   secret_store_id
#   tags
#   token
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )
#   class AKSServiceAccountUserImpersonation:
View Source
class AKSServiceAccountUserImpersonation:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param token: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
        'token',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
    def __repr__(self):
        return '<sdm.AKSServiceAccountUserImpersonation ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param token:

#   AKSServiceAccountUserImpersonation( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None, token=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
#   egress_filter
#   healthcheck_namespace
#   healthy
#   hostname
#   id
#   name
#   port
#   secret_store_id
#   tags
#   token
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )
#   class AKSUserImpersonation:
View Source
class AKSUserImpersonation:
    """

    :param certificate_authority: 
    :param client_certificate: 
    :param client_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'client_certificate',
        'client_key',
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AKSUserImpersonation ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'client_key: ' + repr(self.client_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param certificate_authority: :param client_certificate: :param client_key: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   AKSUserImpersonation( certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
#   certificate_authority
#   client_certificate
#   client_key
#   egress_filter
#   healthcheck_namespace
#   healthy
#   hostname
#   id
#   name
#   port
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class AWS:
View Source
class AWS:
    """

    :param access_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_region: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'egress_filter',
        'healthcheck_region',
        'healthy',
        'id',
        'name',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        egress_filter=None,
        healthcheck_region=None,
        healthy=None,
        id=None,
        name=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.healthcheck_region = healthcheck_region
        self.healthy = healthy
        self.id = id
        self.name = name
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AWS ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'healthcheck_region': self.healthcheck_region,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_region=d.get('healthcheck_region'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param access_key: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_region: :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param role_arn: :param role_external_id: :param secret_access_key: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   AWS( access_key=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        access_key=None,
        egress_filter=None,
        healthcheck_region=None,
        healthy=None,
        id=None,
        name=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.healthcheck_region = healthcheck_region
        self.healthy = healthy
        self.id = id
        self.name = name
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
#   access_key
#   egress_filter
#   healthcheck_region
#   healthy
#   id
#   name
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'healthcheck_region': self.healthcheck_region,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_region=d.get('healthcheck_region'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class AWSStore:
View Source
class AWSStore:
    """

    :param id: Unique identifier of the SecretStore.
    :param name: Unique human-readable name of the SecretStore.
    :param region: 
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'id',
        'name',
        'region',
        'tags',
    ]
    def __init__(self,
        id=None,
        name=None,
        region=None,
        tags=None,
    ):
        self.id = id
        self.name = name
        self.region = region
        self.tags = tags
    def __repr__(self):
        return '<sdm.AWSStore ' + \
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'region': self.region,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            region=d.get('region'),
            tags=d.get('tags'),
        )

:param id: Unique identifier of the SecretStore. :param name: Unique human-readable name of the SecretStore. :param region: :param tags: Tags is a map of key, value pairs.

#   AWSStore(id=None, name=None, region=None, tags=None)
View Source
    def __init__(self,
        id=None,
        name=None,
        region=None,
        tags=None,
    ):
        self.id = id
        self.name = name
        self.region = region
        self.tags = tags
#   id
#   name
#   region
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'region': self.region,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            region=d.get('region'),
            tags=d.get('tags'),
        )
#   class AccountAttachment:
View Source
class AccountAttachment:
    """AccountAttachments assign an account to a role or composite role.

    :param account_id: The id of the account of this AccountAttachment.
    :param id: Unique identifier of the AccountAttachment.
    :param role_id: The id of the attached role of this AccountAttachment.
    """
    __slots__ = [
        'account_id',
        'id',
        'role_id',
    ]
    def __init__(self,
        account_id=None,
        id=None,
        role_id=None,
    ):
        self.account_id = account_id
        self.id = id
        self.role_id = role_id
    def __repr__(self):
        return '<sdm.AccountAttachment ' + \
            'account_id: ' + repr(self.account_id) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'role_id: ' + repr(self.role_id) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_id': self.account_id,
            'id': self.id,
            'role_id': self.role_id,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_id=d.get('account_id'),
            id=d.get('id'),
            role_id=d.get('role_id'),
        )

AccountAttachments assign an account to a role or composite role.

:param account_id: The id of the account of this AccountAttachment. :param id: Unique identifier of the AccountAttachment. :param role_id: The id of the attached role of this AccountAttachment.

#   AccountAttachment(account_id=None, id=None, role_id=None)
View Source
    def __init__(self,
        account_id=None,
        id=None,
        role_id=None,
    ):
        self.account_id = account_id
        self.id = id
        self.role_id = role_id
#   account_id
#   id
#   role_id
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'account_id': self.account_id,
            'id': self.id,
            'role_id': self.role_id,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_id=d.get('account_id'),
            id=d.get('id'),
            role_id=d.get('role_id'),
        )
#   class AccountAttachmentCreateResponse:
View Source
class AccountAttachmentCreateResponse:
    """AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

    :param account_attachment: The created AccountAttachment.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account_attachment',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account_attachment=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_attachment = account_attachment
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountAttachmentCreateResponse ' + \
            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_attachment': self.account_attachment,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_attachment=d.get('account_attachment'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

:param account_attachment: The created AccountAttachment. :param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
View Source
    def __init__(self,
        account_attachment=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_attachment = account_attachment
        self.meta = meta
        self.rate_limit = rate_limit
#   account_attachment
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'account_attachment': self.account_attachment,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_attachment=d.get('account_attachment'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class AccountAttachmentDeleteResponse:
View Source
class AccountAttachmentDeleteResponse:
    """AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountAttachmentDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

:param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class AccountAttachmentGetResponse:
View Source
class AccountAttachmentGetResponse:
    """AccountAttachmentGetResponse returns a requested AccountAttachment.

    :param account_attachment: The requested AccountAttachment.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account_attachment',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account_attachment=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_attachment = account_attachment
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountAttachmentGetResponse ' + \
            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_attachment': self.account_attachment,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_attachment=d.get('account_attachment'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

:param account_attachment: The requested AccountAttachment. :param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
View Source
    def __init__(self,
        account_attachment=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_attachment = account_attachment
        self.meta = meta
        self.rate_limit = rate_limit
#   account_attachment
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'account_attachment': self.account_attachment,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_attachment=d.get('account_attachment'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class AccountCreateResponse:
View Source
class AccountCreateResponse:
    """AccountCreateResponse reports how the Accounts were created in the system.

    :param account: The created Account.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param token: The auth token generated for the Account. The Account will use this token to
 authenticate with the strongDM API.
    """
    __slots__ = [
        'account',
        'meta',
        'rate_limit',
        'token',
    ]
    def __init__(self,
        account=None,
        meta=None,
        rate_limit=None,
        token=None,
    ):
        self.account = account
        self.meta = meta
        self.rate_limit = rate_limit
        self.token = token
    def __repr__(self):
        return '<sdm.AccountCreateResponse ' + \
            'account: ' + repr(self.account) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account': self.account,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account=d.get('account'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            token=d.get('token'),
        )

AccountCreateResponse reports how the Accounts were created in the system.

:param account: The created Account. :param meta: Reserved for future use. :param rate_limit: Rate limit information. :param token: The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

#   AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
View Source
    def __init__(self,
        account=None,
        meta=None,
        rate_limit=None,
        token=None,
    ):
        self.account = account
        self.meta = meta
        self.rate_limit = rate_limit
        self.token = token
#   account
#   meta
#   rate_limit
#   token
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'account': self.account,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'token': self.token,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            account=d.get('account'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            token=d.get('token'),
        )
#   class AccountDeleteResponse:
View Source
class AccountDeleteResponse:
    """AccountDeleteResponse returns information about a Account that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

AccountDeleteResponse returns information about a Account that was deleted.

:param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   AccountDeleteResponse(meta=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class AccountGetResponse:
View Source
class AccountGetResponse:
    """AccountGetResponse returns a requested Account.

    :param account: The requested Account.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account=None,
        meta=None,
        rate_limit=None,
    ):
        self.account = account
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountGetResponse ' + \
            'account: ' + repr(self.account) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account': self.account,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account=d.get('account'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

AccountGetResponse returns a requested Account.

:param account: The requested Account. :param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   AccountGetResponse(account=None, meta=None, rate_limit=None)
View Source
    def __init__(self,
        account=None,
        meta=None,
        rate_limit=None,
    ):
        self.account = account
        self.meta = meta
        self.rate_limit = rate_limit
#   account
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'account': self.account,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            account=d.get('account'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class AccountGrant:
View Source
class AccountGrant:
    """AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

    :param account_id: The id of the attached role of this AccountGrant.
    :param id: Unique identifier of the AccountGrant.
    :param resource_id: The id of the composite role of this AccountGrant.
    :param start_from: The timestamp when the resource will be granted. Optional. Both start_at
 and end_at must be defined together, or not defined at all.
    :param valid_until: The timestamp when the resource grant will expire. Optional. Both
 start_at and end_at must be defined together, or not defined at all.
    """
    __slots__ = [
        'account_id',
        'id',
        'resource_id',
        'start_from',
        'valid_until',
    ]
    def __init__(self,
        account_id=None,
        id=None,
        resource_id=None,
        start_from=None,
        valid_until=None,
    ):
        self.account_id = account_id
        self.id = id
        self.resource_id = resource_id
        self.start_from = start_from
        self.valid_until = valid_until
    def __repr__(self):
        return '<sdm.AccountGrant ' + \
            'account_id: ' + repr(self.account_id) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'resource_id: ' + repr(self.resource_id) + ' ' +\
            'start_from: ' + repr(self.start_from) + ' ' +\
            'valid_until: ' + repr(self.valid_until) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_id': self.account_id,
            'id': self.id,
            'resource_id': self.resource_id,
            'start_from': self.start_from,
            'valid_until': self.valid_until,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_id=d.get('account_id'),
            id=d.get('id'),
            resource_id=d.get('resource_id'),
            start_from=d.get('start_from'),
            valid_until=d.get('valid_until'),
        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

:param account_id: The id of the attached role of this AccountGrant. :param id: Unique identifier of the AccountGrant. :param resource_id: The id of the composite role of this AccountGrant. :param start_from: The timestamp when the resource will be granted. Optional. Both start_at and end_at must be defined together, or not defined at all. :param valid_until: The timestamp when the resource grant will expire. Optional. Both start_at and end_at must be defined together, or not defined at all.

#   AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None )
View Source
    def __init__(self,
        account_id=None,
        id=None,
        resource_id=None,
        start_from=None,
        valid_until=None,
    ):
        self.account_id = account_id
        self.id = id
        self.resource_id = resource_id
        self.start_from = start_from
        self.valid_until = valid_until
#   account_id
#   id
#   resource_id
#   start_from
#   valid_until
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'account_id': self.account_id,
            'id': self.id,
            'resource_id': self.resource_id,
            'start_from': self.start_from,
            'valid_until': self.valid_until,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_id=d.get('account_id'),
            id=d.get('id'),
            resource_id=d.get('resource_id'),
            start_from=d.get('start_from'),
            valid_until=d.get('valid_until'),
        )
#   class AccountGrantCreateResponse:
View Source
class AccountGrantCreateResponse:
    """AccountGrantCreateResponse reports how the AccountGrants were created in the system.

    :param account_grant: The created AccountGrant.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account_grant',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account_grant=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_grant = account_grant
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountGrantCreateResponse ' + \
            'account_grant: ' + repr(self.account_grant) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_grant': self.account_grant,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_grant=d.get('account_grant'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

:param account_grant: The created AccountGrant. :param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
View Source
    def __init__(self,
        account_grant=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_grant = account_grant
        self.meta = meta
        self.rate_limit = rate_limit
#   account_grant
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'account_grant': self.account_grant,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_grant=d.get('account_grant'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class AccountGrantDeleteResponse:
View Source
class AccountGrantDeleteResponse:
    """AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountGrantDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

:param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   AccountGrantDeleteResponse(meta=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class AccountGrantGetResponse:
View Source
class AccountGrantGetResponse:
    """AccountGrantGetResponse returns a requested AccountGrant.

    :param account_grant: The requested AccountGrant.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account_grant',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account_grant=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_grant = account_grant
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountGrantGetResponse ' + \
            'account_grant: ' + repr(self.account_grant) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account_grant': self.account_grant,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_grant=d.get('account_grant'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

AccountGrantGetResponse returns a requested AccountGrant.

:param account_grant: The requested AccountGrant. :param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
View Source
    def __init__(self,
        account_grant=None,
        meta=None,
        rate_limit=None,
    ):
        self.account_grant = account_grant
        self.meta = meta
        self.rate_limit = rate_limit
#   account_grant
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'account_grant': self.account_grant,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            account_grant=d.get('account_grant'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class AccountUpdateResponse:
View Source
class AccountUpdateResponse:
    """AccountUpdateResponse returns the fields of a Account after it has been updated by
 a AccountUpdateRequest.

    :param account: The updated Account.
    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'account',
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        account=None,
        meta=None,
        rate_limit=None,
    ):
        self.account = account
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.AccountUpdateResponse ' + \
            'account: ' + repr(self.account) + ' ' +\
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'account': self.account,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            account=d.get('account'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

:param account: The updated Account. :param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   AccountUpdateResponse(account=None, meta=None, rate_limit=None)
View Source
    def __init__(self,
        account=None,
        meta=None,
        rate_limit=None,
    ):
        self.account = account
        self.meta = meta
        self.rate_limit = rate_limit
#   account
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'account': self.account,
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            account=d.get('account'),
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class AmazonEKS:
View Source
class AmazonEKS:
    """

    :param access_key: 
    :param certificate_authority: 
    :param cluster_name: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'certificate_authority',
        'cluster_name',
        'egress_filter',
        'endpoint',
        'healthcheck_namespace',
        'healthy',
        'id',
        'name',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        certificate_authority=None,
        cluster_name=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.certificate_authority = certificate_authority
        self.cluster_name = cluster_name
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AmazonEKS ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'certificate_authority': self.certificate_authority,
            'cluster_name': self.cluster_name,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            certificate_authority=d.get('certificate_authority'),
            cluster_name=d.get('cluster_name'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param access_key: :param certificate_authority: :param cluster_name: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param endpoint: :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param region: :param role_arn: :param role_external_id: :param secret_access_key: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   AmazonEKS( access_key=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        access_key=None,
        certificate_authority=None,
        cluster_name=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.certificate_authority = certificate_authority
        self.cluster_name = cluster_name
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
#   access_key
#   certificate_authority
#   cluster_name
#   egress_filter
#   endpoint
#   healthcheck_namespace
#   healthy
#   id
#   name
#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'certificate_authority': self.certificate_authority,
            'cluster_name': self.cluster_name,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            certificate_authority=d.get('certificate_authority'),
            cluster_name=d.get('cluster_name'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class AmazonEKSUserImpersonation:
View Source
class AmazonEKSUserImpersonation:
    """

    :param access_key: 
    :param certificate_authority: 
    :param cluster_name: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'certificate_authority',
        'cluster_name',
        'egress_filter',
        'endpoint',
        'healthcheck_namespace',
        'healthy',
        'id',
        'name',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        certificate_authority=None,
        cluster_name=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.certificate_authority = certificate_authority
        self.cluster_name = cluster_name
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AmazonEKSUserImpersonation ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'certificate_authority': self.certificate_authority,
            'cluster_name': self.cluster_name,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            certificate_authority=d.get('certificate_authority'),
            cluster_name=d.get('cluster_name'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param access_key: :param certificate_authority: :param cluster_name: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param endpoint: :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param region: :param role_arn: :param role_external_id: :param secret_access_key: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   AmazonEKSUserImpersonation( access_key=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        access_key=None,
        certificate_authority=None,
        cluster_name=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.certificate_authority = certificate_authority
        self.cluster_name = cluster_name
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
#   access_key
#   certificate_authority
#   cluster_name
#   egress_filter
#   endpoint
#   healthcheck_namespace
#   healthy
#   id
#   name
#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'certificate_authority': self.certificate_authority,
            'cluster_name': self.cluster_name,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            certificate_authority=d.get('certificate_authority'),
            cluster_name=d.get('cluster_name'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class AmazonES:
View Source
class AmazonES:
    """

    :param access_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port_override: 
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'egress_filter',
        'endpoint',
        'healthy',
        'id',
        'name',
        'port_override',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.AmazonES ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param access_key: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param endpoint: :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port_override: :param region: :param role_arn: :param role_external_id: :param secret_access_key: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   AmazonES( access_key=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        access_key=None,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
#   access_key
#   egress_filter
#   endpoint
#   healthy
#   id
#   name
#   port_override
#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class AmazonMQAMQP091:
View Source
class AmazonMQAMQP091:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.AmazonMQAMQP091 ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   AmazonMQAMQP091( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class Athena:
View Source
class Athena:
    """

    :param access_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param output: 
    :param port_override: 
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'egress_filter',
        'healthy',
        'id',
        'name',
        'output',
        'port_override',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        egress_filter=None,
        healthy=None,
        id=None,
        name=None,
        output=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.name = name
        self.output = output
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.Athena ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'output: ' + repr(self.output) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'output': self.output,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            output=d.get('output'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param access_key: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param output: :param port_override: :param region: :param role_arn: :param role_external_id: :param secret_access_key: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   Athena( access_key=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        access_key=None,
        egress_filter=None,
        healthy=None,
        id=None,
        name=None,
        output=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.name = name
        self.output = output
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
#   access_key
#   egress_filter
#   healthy
#   id
#   name
#   output
#   port_override
#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'output': self.output,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            output=d.get('output'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class AuroraMysql:
View Source
class AuroraMysql:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.AuroraMysql ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   AuroraMysql( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class AuroraPostgres:
View Source
class AuroraPostgres:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.AuroraPostgres ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param override_database: :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   AuroraPostgres( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   override_database
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Azure:
View Source
class Azure:
    """

    :param app_id: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tenant_id: 
    """
    __slots__ = [
        'app_id',
        'egress_filter',
        'healthy',
        'id',
        'name',
        'password',
        'secret_store_id',
        'tags',
        'tenant_id',
    ]
    def __init__(self,
        app_id=None,
        egress_filter=None,
        healthy=None,
        id=None,
        name=None,
        password=None,
        secret_store_id=None,
        tags=None,
        tenant_id=None,
    ):
        self.app_id = app_id
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.name = name
        self.password = password
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tenant_id = tenant_id
    def __repr__(self):
        return '<sdm.Azure ' + \
            'app_id: ' + repr(self.app_id) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'app_id': self.app_id,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tenant_id': self.tenant_id,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            app_id=d.get('app_id'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tenant_id=d.get('tenant_id'),
        )

:param app_id: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tenant_id:

#   Azure( app_id=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None )
View Source
    def __init__(self,
        app_id=None,
        egress_filter=None,
        healthy=None,
        id=None,
        name=None,
        password=None,
        secret_store_id=None,
        tags=None,
        tenant_id=None,
    ):
        self.app_id = app_id
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.name = name
        self.password = password
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tenant_id = tenant_id
#   app_id
#   egress_filter
#   healthy
#   id
#   name
#   password
#   secret_store_id
#   tags
#   tenant_id
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'app_id': self.app_id,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tenant_id': self.tenant_id,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            app_id=d.get('app_id'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tenant_id=d.get('tenant_id'),
        )
#   class AzureCertificate:
View Source
class AzureCertificate:
    """

    :param app_id: 
    :param client_certificate: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tenant_id: 
    """
    __slots__ = [
        'app_id',
        'client_certificate',
        'egress_filter',
        'healthy',
        'id',
        'name',
        'secret_store_id',
        'tags',
        'tenant_id',
    ]
    def __init__(self,
        app_id=None,
        client_certificate=None,
        egress_filter=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        tags=None,
        tenant_id=None,
    ):
        self.app_id = app_id
        self.client_certificate = client_certificate
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tenant_id = tenant_id
    def __repr__(self):
        return '<sdm.AzureCertificate ' + \
            'app_id: ' + repr(self.app_id) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'app_id': self.app_id,
            'client_certificate': self.client_certificate,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tenant_id': self.tenant_id,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            app_id=d.get('app_id'),
            client_certificate=d.get('client_certificate'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tenant_id=d.get('tenant_id'),
        )

:param app_id: :param client_certificate: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tenant_id:

#   AzureCertificate( app_id=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None )
View Source
    def __init__(self,
        app_id=None,
        client_certificate=None,
        egress_filter=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        tags=None,
        tenant_id=None,
    ):
        self.app_id = app_id
        self.client_certificate = client_certificate
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tenant_id = tenant_id
#   app_id
#   client_certificate
#   egress_filter
#   healthy
#   id
#   name
#   secret_store_id
#   tags
#   tenant_id
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'app_id': self.app_id,
            'client_certificate': self.client_certificate,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tenant_id': self.tenant_id,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            app_id=d.get('app_id'),
            client_certificate=d.get('client_certificate'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tenant_id=d.get('tenant_id'),
        )
#   class AzurePostgres:
View Source
class AzurePostgres:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.AzurePostgres ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param override_database: :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   AzurePostgres( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   override_database
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class AzureStore:
View Source
class AzureStore:
    """

    :param id: Unique identifier of the SecretStore.
    :param name: Unique human-readable name of the SecretStore.
    :param tags: Tags is a map of key, value pairs.
    :param vault_uri: 
    """
    __slots__ = [
        'id',
        'name',
        'tags',
        'vault_uri',
    ]
    def __init__(self,
        id=None,
        name=None,
        tags=None,
        vault_uri=None,
    ):
        self.id = id
        self.name = name
        self.tags = tags
        self.vault_uri = vault_uri
    def __repr__(self):
        return '<sdm.AzureStore ' + \
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'tags': self.tags,
            'vault_uri': self.vault_uri,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            tags=d.get('tags'),
            vault_uri=d.get('vault_uri'),
        )

:param id: Unique identifier of the SecretStore. :param name: Unique human-readable name of the SecretStore. :param tags: Tags is a map of key, value pairs. :param vault_uri:

#   AzureStore(id=None, name=None, tags=None, vault_uri=None)
View Source
    def __init__(self,
        id=None,
        name=None,
        tags=None,
        vault_uri=None,
    ):
        self.id = id
        self.name = name
        self.tags = tags
        self.vault_uri = vault_uri
#   id
#   name
#   tags
#   vault_uri
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'tags': self.tags,
            'vault_uri': self.vault_uri,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            tags=d.get('tags'),
            vault_uri=d.get('vault_uri'),
        )
#   class BigQuery:
View Source
class BigQuery:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port_override: 
    :param private_key: 
    :param project: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'endpoint',
        'healthy',
        'id',
        'name',
        'port_override',
        'private_key',
        'project',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port_override=None,
        private_key=None,
        project=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port_override = port_override
        self.private_key = private_key
        self.project = project
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.BigQuery ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'private_key: ' + repr(self.private_key) + ' ' +\
            'project: ' + repr(self.project) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port_override': self.port_override,
            'private_key': self.private_key,
            'project': self.project,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port_override=d.get('port_override'),
            private_key=d.get('private_key'),
            project=d.get('project'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param endpoint: :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port_override: :param private_key: :param project: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   BigQuery( egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port_override=None,
        private_key=None,
        project=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port_override = port_override
        self.private_key = private_key
        self.project = project
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   egress_filter
#   endpoint
#   healthy
#   id
#   name
#   port_override
#   private_key
#   project
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port_override': self.port_override,
            'private_key': self.private_key,
            'project': self.project,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port_override=d.get('port_override'),
            private_key=d.get('private_key'),
            project=d.get('project'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Cassandra:
View Source
class Cassandra:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.Cassandra ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   Cassandra( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class Citus:
View Source
class Citus:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Citus ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param override_database: :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Citus( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   override_database
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Clustrix:
View Source
class Clustrix:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Clustrix ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Clustrix( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Cockroach:
View Source
class Cockroach:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Cockroach ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param override_database: :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Cockroach( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   override_database
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class ControlPanelGetSSHCAPublicKeyResponse:
View Source
class ControlPanelGetSSHCAPublicKeyResponse:
    """ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 organization's SSH Certificate Authority public key.

    :param meta: Reserved for future use.
    :param public_key: The public key of the SSH Certificate Authority, in OpenSSH RSA public
 key format.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'public_key',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        public_key=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.public_key = public_key
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'public_key: ' + repr(self.public_key) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'public_key': self.public_key,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            public_key=d.get('public_key'),
            rate_limit=d.get('rate_limit'),
        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

:param meta: Reserved for future use. :param public_key: The public key of the SSH Certificate Authority, in OpenSSH RSA public key format. :param rate_limit: Rate limit information.

#   ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        public_key=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.public_key = public_key
        self.rate_limit = rate_limit
#   meta
#   public_key
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'public_key': self.public_key,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            public_key=d.get('public_key'),
            rate_limit=d.get('rate_limit'),
        )
#   class ControlPanelVerifyJWTResponse:
View Source
class ControlPanelVerifyJWTResponse:
    """ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param valid: Reports if the given token is valid.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'valid',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        valid=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.valid = valid
    def __repr__(self):
        return '<sdm.ControlPanelVerifyJWTResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'valid: ' + repr(self.valid) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'valid': self.valid,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            valid=d.get('valid'),
        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param valid: Reports if the given token is valid.

#   ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        valid=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.valid = valid
#   meta
#   rate_limit
#   valid
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'valid': self.valid,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            valid=d.get('valid'),
        )
#   class CreateResponseMetadata:
View Source
class CreateResponseMetadata:
    """CreateResponseMetadata is reserved for future use."""
    __slots__ = [
    ]
    def __init__(self,
    ):
        pass
    def __repr__(self):
        return '<sdm.CreateResponseMetadata ' + \
            '>'
    def to_dict(self):
        return {
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
        )

CreateResponseMetadata is reserved for future use.

#   CreateResponseMetadata()
View Source
    def __init__(self,
    ):
        pass
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
        )
#   class DB2I:
View Source
class DB2I:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.DB2I ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   DB2I( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class DB2LUW:
View Source
class DB2LUW:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.DB2LUW ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   DB2LUW( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class DeleteResponseMetadata:
View Source
class DeleteResponseMetadata:
    """DeleteResponseMetadata is reserved for future use."""
    __slots__ = [
    ]
    def __init__(self,
    ):
        pass
    def __repr__(self):
        return '<sdm.DeleteResponseMetadata ' + \
            '>'
    def to_dict(self):
        return {
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
        )

DeleteResponseMetadata is reserved for future use.

#   DeleteResponseMetadata()
View Source
    def __init__(self,
    ):
        pass
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
        )
#   class DocumentDBHost:
View Source
class DocumentDBHost:
    """

    :param auth_database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.DocumentDBHost ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param auth_database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   DocumentDBHost( auth_database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   auth_database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class DocumentDBReplicaSet:
View Source
class DocumentDBReplicaSet:
    """

    :param auth_database: 
    :param connect_to_replica: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port_override: 
    :param replica_set: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'connect_to_replica',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port_override',
        'replica_set',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        connect_to_replica=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.connect_to_replica = connect_to_replica
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.DocumentDBReplicaSet ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'replica_set: ' + repr(self.replica_set) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'connect_to_replica': self.connect_to_replica,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            connect_to_replica=d.get('connect_to_replica'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param auth_database: :param connect_to_replica: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port_override: :param replica_set: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   DocumentDBReplicaSet( auth_database=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        auth_database=None,
        connect_to_replica=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.connect_to_replica = connect_to_replica
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   auth_database
#   connect_to_replica
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port_override
#   replica_set
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'connect_to_replica': self.connect_to_replica,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            connect_to_replica=d.get('connect_to_replica'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Druid:
View Source
class Druid:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Druid ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Druid( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class DynamoDB:
View Source
class DynamoDB:
    """

    :param access_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port_override: 
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'egress_filter',
        'endpoint',
        'healthy',
        'id',
        'name',
        'port_override',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.DynamoDB ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param access_key: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param endpoint: :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port_override: :param region: :param role_arn: :param role_external_id: :param secret_access_key: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   DynamoDB( access_key=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        access_key=None,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
#   access_key
#   egress_filter
#   endpoint
#   healthy
#   id
#   name
#   port_override
#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class Elastic:
View Source
class Elastic:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.Elastic ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   Elastic( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class ElasticacheRedis:
View Source
class ElasticacheRedis:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
    def __repr__(self):
        return '<sdm.ElasticacheRedis ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required:

#   ElasticacheRedis( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   tls_required
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
        )
#   class GCP:
View Source
class GCP:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param keyfile: 
    :param name: Unique human-readable name of the Resource.
    :param scopes: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'id',
        'keyfile',
        'name',
        'scopes',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        id=None,
        keyfile=None,
        name=None,
        scopes=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.keyfile = keyfile
        self.name = name
        self.scopes = scopes
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.GCP ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'keyfile: ' + repr(self.keyfile) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'scopes: ' + repr(self.scopes) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'keyfile': self.keyfile,
            'name': self.name,
            'scopes': self.scopes,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            keyfile=d.get('keyfile'),
            name=d.get('name'),
            scopes=d.get('scopes'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param keyfile: :param name: Unique human-readable name of the Resource. :param scopes: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   GCP( egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        id=None,
        keyfile=None,
        name=None,
        scopes=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.id = id
        self.keyfile = keyfile
        self.name = name
        self.scopes = scopes
        self.secret_store_id = secret_store_id
        self.tags = tags
#   egress_filter
#   healthy
#   id
#   keyfile
#   name
#   scopes
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'id': self.id,
            'keyfile': self.keyfile,
            'name': self.name,
            'scopes': self.scopes,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            keyfile=d.get('keyfile'),
            name=d.get('name'),
            scopes=d.get('scopes'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class Gateway:
View Source
class Gateway:
    """Gateway represents a StrongDM CLI installation running in gateway mode.

    :param bind_address: The hostname/port tuple which the gateway daemon will bind to.
 If not provided on create, set to "0.0.0.0:<listen_address_port>".
    :param gateway_filter: GatewayFilter can be used to restrict the peering between relays and
 gateways.
    :param id: Unique identifier of the Gateway.
    :param listen_address: The public hostname/port tuple at which the gateway will be accessible to clients.
    :param name: Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
    :param state: The current state of the gateway. One of: "new", "verifying_restart",
 "restarting", "started", "stopped", "dead", "unknown"
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'bind_address',
        'gateway_filter',
        'id',
        'listen_address',
        'name',
        'state',
        'tags',
    ]
    def __init__(self,
        bind_address=None,
        gateway_filter=None,
        id=None,
        listen_address=None,
        name=None,
        state=None,
        tags=None,
    ):
        self.bind_address = bind_address
        self.gateway_filter = gateway_filter
        self.id = id
        self.listen_address = listen_address
        self.name = name
        self.state = state
        self.tags = tags
    def __repr__(self):
        return '<sdm.Gateway ' + \
            'bind_address: ' + repr(self.bind_address) + ' ' +\
            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'listen_address: ' + repr(self.listen_address) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'state: ' + repr(self.state) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'bind_address': self.bind_address,
            'gateway_filter': self.gateway_filter,
            'id': self.id,
            'listen_address': self.listen_address,
            'name': self.name,
            'state': self.state,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            bind_address=d.get('bind_address'),
            gateway_filter=d.get('gateway_filter'),
            id=d.get('id'),
            listen_address=d.get('listen_address'),
            name=d.get('name'),
            state=d.get('state'),
            tags=d.get('tags'),
        )

Gateway represents a StrongDM CLI installation running in gateway mode.

:param bind_address: The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:". :param gateway_filter: GatewayFilter can be used to restrict the peering between relays and gateways. :param id: Unique identifier of the Gateway. :param listen_address: The public hostname/port tuple at which the gateway will be accessible to clients. :param name: Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create. :param state: The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown" :param tags: Tags is a map of key, value pairs.

#   Gateway( bind_address=None, gateway_filter=None, id=None, listen_address=None, name=None, state=None, tags=None )
View Source
    def __init__(self,
        bind_address=None,
        gateway_filter=None,
        id=None,
        listen_address=None,
        name=None,
        state=None,
        tags=None,
    ):
        self.bind_address = bind_address
        self.gateway_filter = gateway_filter
        self.id = id
        self.listen_address = listen_address
        self.name = name
        self.state = state
        self.tags = tags
#   bind_address
#   gateway_filter
#   id
#   listen_address
#   name
#   state
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'bind_address': self.bind_address,
            'gateway_filter': self.gateway_filter,
            'id': self.id,
            'listen_address': self.listen_address,
            'name': self.name,
            'state': self.state,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            bind_address=d.get('bind_address'),
            gateway_filter=d.get('gateway_filter'),
            id=d.get('id'),
            listen_address=d.get('listen_address'),
            name=d.get('name'),
            state=d.get('state'),
            tags=d.get('tags'),
        )
#   class GetResponseMetadata:
View Source
class GetResponseMetadata:
    """GetResponseMetadata is reserved for future use."""
    __slots__ = [
    ]
    def __init__(self,
    ):
        pass
    def __repr__(self):
        return '<sdm.GetResponseMetadata ' + \
            '>'
    def to_dict(self):
        return {
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
        )

GetResponseMetadata is reserved for future use.

#   GetResponseMetadata()
View Source
    def __init__(self,
    ):
        pass
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
        )
#   class GoogleGKE:
View Source
class GoogleGKE:
    """

    :param certificate_authority: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param service_account_key: 
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'egress_filter',
        'endpoint',
        'healthcheck_namespace',
        'healthy',
        'id',
        'name',
        'secret_store_id',
        'service_account_key',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        service_account_key=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.service_account_key = service_account_key
        self.tags = tags
    def __repr__(self):
        return '<sdm.GoogleGKE ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'service_account_key': self.service_account_key,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            service_account_key=d.get('service_account_key'),
            tags=d.get('tags'),
        )

:param certificate_authority: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param endpoint: :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param service_account_key: :param tags: Tags is a map of key, value pairs.

#   GoogleGKE( certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None )
View Source
    def __init__(self,
        certificate_authority=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        service_account_key=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.service_account_key = service_account_key
        self.tags = tags
#   certificate_authority
#   egress_filter
#   endpoint
#   healthcheck_namespace
#   healthy
#   id
#   name
#   secret_store_id
#   service_account_key
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'service_account_key': self.service_account_key,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            service_account_key=d.get('service_account_key'),
            tags=d.get('tags'),
        )
#   class GoogleGKEUserImpersonation:
View Source
class GoogleGKEUserImpersonation:
    """

    :param certificate_authority: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param service_account_key: 
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'egress_filter',
        'endpoint',
        'healthcheck_namespace',
        'healthy',
        'id',
        'name',
        'secret_store_id',
        'service_account_key',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        service_account_key=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.service_account_key = service_account_key
        self.tags = tags
    def __repr__(self):
        return '<sdm.GoogleGKEUserImpersonation ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'service_account_key': self.service_account_key,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            service_account_key=d.get('service_account_key'),
            tags=d.get('tags'),
        )

:param certificate_authority: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param endpoint: :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param service_account_key: :param tags: Tags is a map of key, value pairs.

#   GoogleGKEUserImpersonation( certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None )
View Source
    def __init__(self,
        certificate_authority=None,
        egress_filter=None,
        endpoint=None,
        healthcheck_namespace=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        service_account_key=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.service_account_key = service_account_key
        self.tags = tags
#   certificate_authority
#   egress_filter
#   endpoint
#   healthcheck_namespace
#   healthy
#   id
#   name
#   secret_store_id
#   service_account_key
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'service_account_key': self.service_account_key,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            service_account_key=d.get('service_account_key'),
            tags=d.get('tags'),
        )
#   class Greenplum:
View Source
class Greenplum:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Greenplum ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param override_database: :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Greenplum( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   override_database
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class HTTPAuth:
View Source
class HTTPAuth:
    """

    :param auth_header: 
    :param default_path: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param headers_blacklist: 
    :param healthcheck_path: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param subdomain: 
    :param tags: Tags is a map of key, value pairs.
    :param url: 
    """
    __slots__ = [
        'auth_header',
        'default_path',
        'egress_filter',
        'headers_blacklist',
        'healthcheck_path',
        'healthy',
        'id',
        'name',
        'secret_store_id',
        'subdomain',
        'tags',
        'url',
    ]
    def __init__(self,
        auth_header=None,
        default_path=None,
        egress_filter=None,
        headers_blacklist=None,
        healthcheck_path=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        subdomain=None,
        tags=None,
        url=None,
    ):
        self.auth_header = auth_header
        self.default_path = default_path
        self.egress_filter = egress_filter
        self.headers_blacklist = headers_blacklist
        self.healthcheck_path = healthcheck_path
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.subdomain = subdomain
        self.tags = tags
        self.url = url
    def __repr__(self):
        return '<sdm.HTTPAuth ' + \
            'auth_header: ' + repr(self.auth_header) + ' ' +\
            'default_path: ' + repr(self.default_path) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'subdomain: ' + repr(self.subdomain) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'url: ' + repr(self.url) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_header': self.auth_header,
            'default_path': self.default_path,
            'egress_filter': self.egress_filter,
            'headers_blacklist': self.headers_blacklist,
            'healthcheck_path': self.healthcheck_path,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'subdomain': self.subdomain,
            'tags': self.tags,
            'url': self.url,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_header=d.get('auth_header'),
            default_path=d.get('default_path'),
            egress_filter=d.get('egress_filter'),
            headers_blacklist=d.get('headers_blacklist'),
            healthcheck_path=d.get('healthcheck_path'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            subdomain=d.get('subdomain'),
            tags=d.get('tags'),
            url=d.get('url'),
        )

:param auth_header: :param default_path: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param headers_blacklist: :param healthcheck_path: :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param subdomain: :param tags: Tags is a map of key, value pairs. :param url:

#   HTTPAuth( auth_header=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None )
View Source
    def __init__(self,
        auth_header=None,
        default_path=None,
        egress_filter=None,
        headers_blacklist=None,
        healthcheck_path=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        subdomain=None,
        tags=None,
        url=None,
    ):
        self.auth_header = auth_header
        self.default_path = default_path
        self.egress_filter = egress_filter
        self.headers_blacklist = headers_blacklist
        self.healthcheck_path = healthcheck_path
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.subdomain = subdomain
        self.tags = tags
        self.url = url
#   auth_header
#   default_path
#   egress_filter
#   headers_blacklist
#   healthcheck_path
#   healthy
#   id
#   name
#   secret_store_id
#   subdomain
#   tags
#   url
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'auth_header': self.auth_header,
            'default_path': self.default_path,
            'egress_filter': self.egress_filter,
            'headers_blacklist': self.headers_blacklist,
            'healthcheck_path': self.healthcheck_path,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'subdomain': self.subdomain,
            'tags': self.tags,
            'url': self.url,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_header=d.get('auth_header'),
            default_path=d.get('default_path'),
            egress_filter=d.get('egress_filter'),
            headers_blacklist=d.get('headers_blacklist'),
            healthcheck_path=d.get('healthcheck_path'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            subdomain=d.get('subdomain'),
            tags=d.get('tags'),
            url=d.get('url'),
        )
#   class HTTPBasicAuth:
View Source
class HTTPBasicAuth:
    """

    :param default_path: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param headers_blacklist: 
    :param healthcheck_path: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param subdomain: 
    :param tags: Tags is a map of key, value pairs.
    :param url: 
    :param username: 
    """
    __slots__ = [
        'default_path',
        'egress_filter',
        'headers_blacklist',
        'healthcheck_path',
        'healthy',
        'id',
        'name',
        'password',
        'secret_store_id',
        'subdomain',
        'tags',
        'url',
        'username',
    ]
    def __init__(self,
        default_path=None,
        egress_filter=None,
        headers_blacklist=None,
        healthcheck_path=None,
        healthy=None,
        id=None,
        name=None,
        password=None,
        secret_store_id=None,
        subdomain=None,
        tags=None,
        url=None,
        username=None,
    ):
        self.default_path = default_path
        self.egress_filter = egress_filter
        self.headers_blacklist = headers_blacklist
        self.healthcheck_path = healthcheck_path
        self.healthy = healthy
        self.id = id
        self.name = name
        self.password = password
        self.secret_store_id = secret_store_id
        self.subdomain = subdomain
        self.tags = tags
        self.url = url
        self.username = username
    def __repr__(self):
        return '<sdm.HTTPBasicAuth ' + \
            'default_path: ' + repr(self.default_path) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'subdomain: ' + repr(self.subdomain) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'url: ' + repr(self.url) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'default_path': self.default_path,
            'egress_filter': self.egress_filter,
            'headers_blacklist': self.headers_blacklist,
            'healthcheck_path': self.healthcheck_path,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'secret_store_id': self.secret_store_id,
            'subdomain': self.subdomain,
            'tags': self.tags,
            'url': self.url,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            default_path=d.get('default_path'),
            egress_filter=d.get('egress_filter'),
            headers_blacklist=d.get('headers_blacklist'),
            healthcheck_path=d.get('healthcheck_path'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            secret_store_id=d.get('secret_store_id'),
            subdomain=d.get('subdomain'),
            tags=d.get('tags'),
            url=d.get('url'),
            username=d.get('username'),
        )

:param default_path: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param headers_blacklist: :param healthcheck_path: :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param subdomain: :param tags: Tags is a map of key, value pairs. :param url: :param username:

#   HTTPBasicAuth( default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None )
View Source
    def __init__(self,
        default_path=None,
        egress_filter=None,
        headers_blacklist=None,
        healthcheck_path=None,
        healthy=None,
        id=None,
        name=None,
        password=None,
        secret_store_id=None,
        subdomain=None,
        tags=None,
        url=None,
        username=None,
    ):
        self.default_path = default_path
        self.egress_filter = egress_filter
        self.headers_blacklist = headers_blacklist
        self.healthcheck_path = healthcheck_path
        self.healthy = healthy
        self.id = id
        self.name = name
        self.password = password
        self.secret_store_id = secret_store_id
        self.subdomain = subdomain
        self.tags = tags
        self.url = url
        self.username = username
#   default_path
#   egress_filter
#   headers_blacklist
#   healthcheck_path
#   healthy
#   id
#   name
#   password
#   secret_store_id
#   subdomain
#   tags
#   url
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'default_path': self.default_path,
            'egress_filter': self.egress_filter,
            'headers_blacklist': self.headers_blacklist,
            'healthcheck_path': self.healthcheck_path,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'secret_store_id': self.secret_store_id,
            'subdomain': self.subdomain,
            'tags': self.tags,
            'url': self.url,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            default_path=d.get('default_path'),
            egress_filter=d.get('egress_filter'),
            headers_blacklist=d.get('headers_blacklist'),
            healthcheck_path=d.get('healthcheck_path'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            secret_store_id=d.get('secret_store_id'),
            subdomain=d.get('subdomain'),
            tags=d.get('tags'),
            url=d.get('url'),
            username=d.get('username'),
        )
#   class HTTPNoAuth:
View Source
class HTTPNoAuth:
    """

    :param default_path: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param headers_blacklist: 
    :param healthcheck_path: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param subdomain: 
    :param tags: Tags is a map of key, value pairs.
    :param url: 
    """
    __slots__ = [
        'default_path',
        'egress_filter',
        'headers_blacklist',
        'healthcheck_path',
        'healthy',
        'id',
        'name',
        'secret_store_id',
        'subdomain',
        'tags',
        'url',
    ]
    def __init__(self,
        default_path=None,
        egress_filter=None,
        headers_blacklist=None,
        healthcheck_path=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        subdomain=None,
        tags=None,
        url=None,
    ):
        self.default_path = default_path
        self.egress_filter = egress_filter
        self.headers_blacklist = headers_blacklist
        self.healthcheck_path = healthcheck_path
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.subdomain = subdomain
        self.tags = tags
        self.url = url
    def __repr__(self):
        return '<sdm.HTTPNoAuth ' + \
            'default_path: ' + repr(self.default_path) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'subdomain: ' + repr(self.subdomain) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'url: ' + repr(self.url) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'default_path': self.default_path,
            'egress_filter': self.egress_filter,
            'headers_blacklist': self.headers_blacklist,
            'healthcheck_path': self.healthcheck_path,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'subdomain': self.subdomain,
            'tags': self.tags,
            'url': self.url,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            default_path=d.get('default_path'),
            egress_filter=d.get('egress_filter'),
            headers_blacklist=d.get('headers_blacklist'),
            healthcheck_path=d.get('healthcheck_path'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            subdomain=d.get('subdomain'),
            tags=d.get('tags'),
            url=d.get('url'),
        )

:param default_path: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param headers_blacklist: :param healthcheck_path: :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param subdomain: :param tags: Tags is a map of key, value pairs. :param url:

#   HTTPNoAuth( default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None )
View Source
    def __init__(self,
        default_path=None,
        egress_filter=None,
        headers_blacklist=None,
        healthcheck_path=None,
        healthy=None,
        id=None,
        name=None,
        secret_store_id=None,
        subdomain=None,
        tags=None,
        url=None,
    ):
        self.default_path = default_path
        self.egress_filter = egress_filter
        self.headers_blacklist = headers_blacklist
        self.healthcheck_path = healthcheck_path
        self.healthy = healthy
        self.id = id
        self.name = name
        self.secret_store_id = secret_store_id
        self.subdomain = subdomain
        self.tags = tags
        self.url = url
#   default_path
#   egress_filter
#   headers_blacklist
#   healthcheck_path
#   healthy
#   id
#   name
#   secret_store_id
#   subdomain
#   tags
#   url
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'default_path': self.default_path,
            'egress_filter': self.egress_filter,
            'headers_blacklist': self.headers_blacklist,
            'healthcheck_path': self.healthcheck_path,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'secret_store_id': self.secret_store_id,
            'subdomain': self.subdomain,
            'tags': self.tags,
            'url': self.url,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            default_path=d.get('default_path'),
            egress_filter=d.get('egress_filter'),
            headers_blacklist=d.get('headers_blacklist'),
            healthcheck_path=d.get('healthcheck_path'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            secret_store_id=d.get('secret_store_id'),
            subdomain=d.get('subdomain'),
            tags=d.get('tags'),
            url=d.get('url'),
        )
#   class Kubernetes:
View Source
class Kubernetes:
    """

    :param certificate_authority: 
    :param client_certificate: 
    :param client_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'client_certificate',
        'client_key',
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.Kubernetes ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'client_key: ' + repr(self.client_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param certificate_authority: :param client_certificate: :param client_key: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   Kubernetes( certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
#   certificate_authority
#   client_certificate
#   client_key
#   egress_filter
#   healthcheck_namespace
#   healthy
#   hostname
#   id
#   name
#   port
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class KubernetesBasicAuth:
View Source
class KubernetesBasicAuth:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.KubernetesBasicAuth ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   KubernetesBasicAuth( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   egress_filter
#   healthcheck_namespace
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class KubernetesServiceAccount:
View Source
class KubernetesServiceAccount:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param token: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
        'token',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
    def __repr__(self):
        return '<sdm.KubernetesServiceAccount ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param token:

#   KubernetesServiceAccount( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None, token=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
#   egress_filter
#   healthcheck_namespace
#   healthy
#   hostname
#   id
#   name
#   port
#   secret_store_id
#   tags
#   token
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )
#   class KubernetesServiceAccountUserImpersonation:
View Source
class KubernetesServiceAccountUserImpersonation:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param token: 
    """
    __slots__ = [
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
        'token',
    ]
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
    def __repr__(self):
        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param token:

#   KubernetesServiceAccountUserImpersonation( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None, token=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
        token=None,
    ):
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.token = token
#   egress_filter
#   healthcheck_namespace
#   healthy
#   hostname
#   id
#   name
#   port
#   secret_store_id
#   tags
#   token
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'token': self.token,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            token=d.get('token'),
        )
#   class KubernetesUserImpersonation:
View Source
class KubernetesUserImpersonation:
    """

    :param certificate_authority: 
    :param client_certificate: 
    :param client_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthcheck_namespace: The path used to check the health of your connection.  Defaults to `default`.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'certificate_authority',
        'client_certificate',
        'client_key',
        'egress_filter',
        'healthcheck_namespace',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.KubernetesUserImpersonation ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'client_key: ' + repr(self.client_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param certificate_authority: :param client_certificate: :param client_key: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthcheck_namespace: The path used to check the health of your connection. Defaults to default. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   KubernetesUserImpersonation( certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        egress_filter=None,
        healthcheck_namespace=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        secret_store_id=None,
        tags=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.egress_filter = egress_filter
        self.healthcheck_namespace = healthcheck_namespace
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.secret_store_id = secret_store_id
        self.tags = tags
#   certificate_authority
#   client_certificate
#   client_key
#   egress_filter
#   healthcheck_namespace
#   healthy
#   hostname
#   id
#   name
#   port
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'egress_filter': self.egress_filter,
            'healthcheck_namespace': self.healthcheck_namespace,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            egress_filter=d.get('egress_filter'),
            healthcheck_namespace=d.get('healthcheck_namespace'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class MTLSPostgres:
View Source
class MTLSPostgres:
    """

    :param certificate_authority: 
    :param client_certificate: 
    :param client_key: 
    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param server_name: 
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'certificate_authority',
        'client_certificate',
        'client_key',
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'server_name',
        'tags',
        'username',
    ]
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        server_name=None,
        tags=None,
        username=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.server_name = server_name
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.MTLSPostgres ' + \
            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
            'client_key: ' + repr(self.client_key) + ' ' +\
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'server_name: ' + repr(self.server_name) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'server_name': self.server_name,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            server_name=d.get('server_name'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param certificate_authority: :param client_certificate: :param client_key: :param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param override_database: :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param server_name: :param tags: Tags is a map of key, value pairs. :param username:

#   MTLSPostgres( certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None )
View Source
    def __init__(self,
        certificate_authority=None,
        client_certificate=None,
        client_key=None,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        server_name=None,
        tags=None,
        username=None,
    ):
        self.certificate_authority = certificate_authority
        self.client_certificate = client_certificate
        self.client_key = client_key
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.server_name = server_name
        self.tags = tags
        self.username = username
#   certificate_authority
#   client_certificate
#   client_key
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   override_database
#   password
#   port
#   port_override
#   secret_store_id
#   server_name
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'certificate_authority': self.certificate_authority,
            'client_certificate': self.client_certificate,
            'client_key': self.client_key,
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'server_name': self.server_name,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            certificate_authority=d.get('certificate_authority'),
            client_certificate=d.get('client_certificate'),
            client_key=d.get('client_key'),
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            server_name=d.get('server_name'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Maria:
View Source
class Maria:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Maria ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Maria( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Memcached:
View Source
class Memcached:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.Memcached ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   Memcached( egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   port
#   port_override
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class Memsql:
View Source
class Memsql:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Memsql ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Memsql( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class MongoHost:
View Source
class MongoHost:
    """

    :param auth_database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.MongoHost ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param auth_database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   MongoHost( auth_database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   auth_database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class MongoLegacyHost:
View Source
class MongoLegacyHost:
    """

    :param auth_database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param replica_set: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'replica_set',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.MongoLegacyHost ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'replica_set: ' + repr(self.replica_set) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param auth_database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param replica_set: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   MongoLegacyHost( auth_database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   auth_database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   replica_set
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class MongoLegacyReplicaset:
View Source
class MongoLegacyReplicaset:
    """

    :param auth_database: 
    :param connect_to_replica: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param replica_set: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'connect_to_replica',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'replica_set',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        connect_to_replica=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.connect_to_replica = connect_to_replica
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.MongoLegacyReplicaset ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'replica_set: ' + repr(self.replica_set) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'connect_to_replica': self.connect_to_replica,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            connect_to_replica=d.get('connect_to_replica'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param auth_database: :param connect_to_replica: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param replica_set: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   MongoLegacyReplicaset( auth_database=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        auth_database=None,
        connect_to_replica=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.connect_to_replica = connect_to_replica
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   auth_database
#   connect_to_replica
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   replica_set
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'connect_to_replica': self.connect_to_replica,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            connect_to_replica=d.get('connect_to_replica'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class MongoReplicaSet:
View Source
class MongoReplicaSet:
    """

    :param auth_database: 
    :param connect_to_replica: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param replica_set: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'connect_to_replica',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'replica_set',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        connect_to_replica=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.connect_to_replica = connect_to_replica
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.MongoReplicaSet ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'replica_set: ' + repr(self.replica_set) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'connect_to_replica': self.connect_to_replica,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            connect_to_replica=d.get('connect_to_replica'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param auth_database: :param connect_to_replica: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param replica_set: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   MongoReplicaSet( auth_database=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        auth_database=None,
        connect_to_replica=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        replica_set=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.connect_to_replica = connect_to_replica
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.replica_set = replica_set
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   auth_database
#   connect_to_replica
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   replica_set
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'connect_to_replica': self.connect_to_replica,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'replica_set': self.replica_set,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            connect_to_replica=d.get('connect_to_replica'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            replica_set=d.get('replica_set'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class MongoShardedCluster:
View Source
class MongoShardedCluster:
    """

    :param auth_database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'auth_database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.MongoShardedCluster ' + \
            'auth_database: ' + repr(self.auth_database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param auth_database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   MongoShardedCluster( auth_database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        auth_database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.auth_database = auth_database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   auth_database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port_override
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'auth_database': self.auth_database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            auth_database=d.get('auth_database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class Mysql:
View Source
class Mysql:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Mysql ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Mysql( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Neptune:
View Source
class Neptune:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'egress_filter',
        'endpoint',
        'healthy',
        'id',
        'name',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.Neptune ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param endpoint: :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   Neptune( egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
#   egress_filter
#   endpoint
#   healthy
#   id
#   name
#   port
#   port_override
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class NeptuneIAM:
View Source
class NeptuneIAM:
    """

    :param access_key: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param endpoint: 
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_override: 
    :param region: 
    :param role_arn: 
    :param role_external_id: 
    :param secret_access_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_key',
        'egress_filter',
        'endpoint',
        'healthy',
        'id',
        'name',
        'port',
        'port_override',
        'region',
        'role_arn',
        'role_external_id',
        'secret_access_key',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        access_key=None,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.NeptuneIAM ' + \
            'access_key: ' + repr(self.access_key) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'endpoint: ' + repr(self.endpoint) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'region: ' + repr(self.region) + ' ' +\
            'role_arn: ' + repr(self.role_arn) + ' ' +\
            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param access_key: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param endpoint: :param healthy: True if the datasource is reachable and the credentials are valid. :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param port_override: :param region: :param role_arn: :param role_external_id: :param secret_access_key: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   NeptuneIAM( access_key=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        access_key=None,
        egress_filter=None,
        endpoint=None,
        healthy=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        region=None,
        role_arn=None,
        role_external_id=None,
        secret_access_key=None,
        secret_store_id=None,
        tags=None,
    ):
        self.access_key = access_key
        self.egress_filter = egress_filter
        self.endpoint = endpoint
        self.healthy = healthy
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.region = region
        self.role_arn = role_arn
        self.role_external_id = role_external_id
        self.secret_access_key = secret_access_key
        self.secret_store_id = secret_store_id
        self.tags = tags
#   access_key
#   egress_filter
#   endpoint
#   healthy
#   id
#   name
#   port
#   port_override
#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'access_key': self.access_key,
            'egress_filter': self.egress_filter,
            'endpoint': self.endpoint,
            'healthy': self.healthy,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'region': self.region,
            'role_arn': self.role_arn,
            'role_external_id': self.role_external_id,
            'secret_access_key': self.secret_access_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_key=d.get('access_key'),
            egress_filter=d.get('egress_filter'),
            endpoint=d.get('endpoint'),
            healthy=d.get('healthy'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            region=d.get('region'),
            role_arn=d.get('role_arn'),
            role_external_id=d.get('role_external_id'),
            secret_access_key=d.get('secret_access_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class NodeCreateResponse:
View Source
class NodeCreateResponse:
    """NodeCreateResponse reports how the Nodes were created in the system.

    :param meta: Reserved for future use.
    :param node: The created Node.
    :param rate_limit: Rate limit information.
    :param token: The auth token generated for the Node. The Node will use this token to
 authenticate with the strongDM API.
    """
    __slots__ = [
        'meta',
        'node',
        'rate_limit',
        'token',
    ]
    def __init__(self,
        meta=None,
        node=None,
        rate_limit=None,
        token=None,
    ):
        self.meta = meta
        self.node = node
        self.rate_limit = rate_limit
        self.token = token
    def __repr__(self):
        return '<sdm.NodeCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'node: ' + repr(self.node) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'token: ' + repr(self.token) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'node': self.node,
            'rate_limit': self.rate_limit,
            'token': self.token,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            node=d.get('node'),
            rate_limit=d.get('rate_limit'),
            token=d.get('token'),
        )

NodeCreateResponse reports how the Nodes were created in the system.

:param meta: Reserved for future use. :param node: The created Node. :param rate_limit: Rate limit information. :param token: The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

#   NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
View Source
    def __init__(self,
        meta=None,
        node=None,
        rate_limit=None,
        token=None,
    ):
        self.meta = meta
        self.node = node
        self.rate_limit = rate_limit
        self.token = token
#   meta
#   node
#   rate_limit
#   token
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'node': self.node,
            'rate_limit': self.rate_limit,
            'token': self.token,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            node=d.get('node'),
            rate_limit=d.get('rate_limit'),
            token=d.get('token'),
        )
#   class NodeDeleteResponse:
View Source
class NodeDeleteResponse:
    """NodeDeleteResponse returns information about a Node that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.NodeDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

NodeDeleteResponse returns information about a Node that was deleted.

:param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   NodeDeleteResponse(meta=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class NodeGetResponse:
View Source
class NodeGetResponse:
    """NodeGetResponse returns a requested Node.

    :param meta: Reserved for future use.
    :param node: The requested Node.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'node',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        node=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.node = node
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.NodeGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'node: ' + repr(self.node) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'node': self.node,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            node=d.get('node'),
            rate_limit=d.get('rate_limit'),
        )

NodeGetResponse returns a requested Node.

:param meta: Reserved for future use. :param node: The requested Node. :param rate_limit: Rate limit information.

#   NodeGetResponse(meta=None, node=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        node=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.node = node
        self.rate_limit = rate_limit
#   meta
#   node
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'node': self.node,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            node=d.get('node'),
            rate_limit=d.get('rate_limit'),
        )
#   class NodeUpdateResponse:
View Source
class NodeUpdateResponse:
    """NodeUpdateResponse returns the fields of a Node after it has been updated by
 a NodeUpdateRequest.

    :param meta: Reserved for future use.
    :param node: The updated Node.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'node',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        node=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.node = node
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.NodeUpdateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'node: ' + repr(self.node) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'node': self.node,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            node=d.get('node'),
            rate_limit=d.get('rate_limit'),
        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

:param meta: Reserved for future use. :param node: The updated Node. :param rate_limit: Rate limit information.

#   NodeUpdateResponse(meta=None, node=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        node=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.node = node
        self.rate_limit = rate_limit
#   meta
#   node
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'node': self.node,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            node=d.get('node'),
            rate_limit=d.get('rate_limit'),
        )
#   class Oracle:
View Source
class Oracle:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.Oracle ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   Oracle( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class Postgres:
View Source
class Postgres:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Postgres ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param override_database: :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Postgres( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   override_database
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Presto:
View Source
class Presto:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.Presto ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   Presto( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class RDP:
View Source
class RDP:
    """

    :param downgrade_nla_connections: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'downgrade_nla_connections',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        downgrade_nla_connections=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.downgrade_nla_connections = downgrade_nla_connections
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.RDP ' + \
            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'downgrade_nla_connections': self.downgrade_nla_connections,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            downgrade_nla_connections=d.get('downgrade_nla_connections'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param downgrade_nla_connections: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   RDP( downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        downgrade_nla_connections=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.downgrade_nla_connections = downgrade_nla_connections
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   downgrade_nla_connections
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'downgrade_nla_connections': self.downgrade_nla_connections,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            downgrade_nla_connections=d.get('downgrade_nla_connections'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class RabbitMQAMQP091:
View Source
class RabbitMQAMQP091:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param tls_required: 
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'tls_required',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
    def __repr__(self):
        return '<sdm.RabbitMQAMQP091 ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'tls_required: ' + repr(self.tls_required) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param tls_required: :param username:

#   RabbitMQAMQP091( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        tls_required=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.tls_required = tls_required
        self.username = username
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   tls_required
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'tls_required': self.tls_required,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            tls_required=d.get('tls_required'),
            username=d.get('username'),
        )
#   class RateLimitMetadata:
View Source
class RateLimitMetadata:
    """RateLimitMetadata contains information about remaining requests avaialable
 to the user over some timeframe.

    :param bucket: The bucket this user/token is associated with, which may be shared between
 multiple users/tokens.
    :param limit: How many total requests the user/token is authorized to make before being
 rate limited.
    :param remaining: How many remaining requests out of the limit are still avaialable.
    :param reset_at: The time when remaining will be reset to limit.
    """
    __slots__ = [
        'bucket',
        'limit',
        'remaining',
        'reset_at',
    ]
    def __init__(self,
        bucket=None,
        limit=None,
        remaining=None,
        reset_at=None,
    ):
        self.bucket = bucket
        self.limit = limit
        self.remaining = remaining
        self.reset_at = reset_at
    def __repr__(self):
        return '<sdm.RateLimitMetadata ' + \
            'bucket: ' + repr(self.bucket) + ' ' +\
            'limit: ' + repr(self.limit) + ' ' +\
            'remaining: ' + repr(self.remaining) + ' ' +\
            'reset_at: ' + repr(self.reset_at) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'bucket': self.bucket,
            'limit': self.limit,
            'remaining': self.remaining,
            'reset_at': self.reset_at,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            bucket=d.get('bucket'),
            limit=d.get('limit'),
            remaining=d.get('remaining'),
            reset_at=d.get('reset_at'),
        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

:param bucket: The bucket this user/token is associated with, which may be shared between multiple users/tokens. :param limit: How many total requests the user/token is authorized to make before being rate limited. :param remaining: How many remaining requests out of the limit are still avaialable. :param reset_at: The time when remaining will be reset to limit.

#   RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
View Source
    def __init__(self,
        bucket=None,
        limit=None,
        remaining=None,
        reset_at=None,
    ):
        self.bucket = bucket
        self.limit = limit
        self.remaining = remaining
        self.reset_at = reset_at
#   bucket
#   limit
#   remaining
#   reset_at
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'bucket': self.bucket,
            'limit': self.limit,
            'remaining': self.remaining,
            'reset_at': self.reset_at,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            bucket=d.get('bucket'),
            limit=d.get('limit'),
            remaining=d.get('remaining'),
            reset_at=d.get('reset_at'),
        )
#   class RawTCP:
View Source
class RawTCP:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.RawTCP ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   RawTCP( egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   port
#   port_override
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class Redis:
View Source
class Redis:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
    def __repr__(self):
        return '<sdm.Redis ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs.

#   Redis( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
        )
#   class Redshift:
View Source
class Redshift:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Redshift ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param override_database: :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Redshift( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   override_database
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Relay:
View Source
class Relay:
    """Relay represents a StrongDM CLI installation running in relay mode.

    :param gateway_filter: GatewayFilter can be used to restrict the peering between relays and
 gateways.
    :param id: Unique identifier of the Relay.
    :param name: Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
    :param state: The current state of the relay. One of: "new", "verifying_restart",
 "awaiting_restart", "restarting", "started", "stopped", "dead",
 "unknown".
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'gateway_filter',
        'id',
        'name',
        'state',
        'tags',
    ]
    def __init__(self,
        gateway_filter=None,
        id=None,
        name=None,
        state=None,
        tags=None,
    ):
        self.gateway_filter = gateway_filter
        self.id = id
        self.name = name
        self.state = state
        self.tags = tags
    def __repr__(self):
        return '<sdm.Relay ' + \
            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'state: ' + repr(self.state) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'gateway_filter': self.gateway_filter,
            'id': self.id,
            'name': self.name,
            'state': self.state,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            gateway_filter=d.get('gateway_filter'),
            id=d.get('id'),
            name=d.get('name'),
            state=d.get('state'),
            tags=d.get('tags'),
        )

Relay represents a StrongDM CLI installation running in relay mode.

:param gateway_filter: GatewayFilter can be used to restrict the peering between relays and gateways. :param id: Unique identifier of the Relay. :param name: Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create. :param state: The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown". :param tags: Tags is a map of key, value pairs.

#   Relay(gateway_filter=None, id=None, name=None, state=None, tags=None)
View Source
    def __init__(self,
        gateway_filter=None,
        id=None,
        name=None,
        state=None,
        tags=None,
    ):
        self.gateway_filter = gateway_filter
        self.id = id
        self.name = name
        self.state = state
        self.tags = tags
#   gateway_filter
#   id
#   name
#   state
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'gateway_filter': self.gateway_filter,
            'id': self.id,
            'name': self.name,
            'state': self.state,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            gateway_filter=d.get('gateway_filter'),
            id=d.get('id'),
            name=d.get('name'),
            state=d.get('state'),
            tags=d.get('tags'),
        )
#   class ResourceCreateResponse:
View Source
class ResourceCreateResponse:
    """ResourceCreateResponse reports how the Resources were created in the system.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param resource: The created Resource.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'resource',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        resource=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.resource = resource
    def __repr__(self):
        return '<sdm.ResourceCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'resource: ' + repr(self.resource) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'resource': self.resource,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            resource=d.get('resource'),
        )

ResourceCreateResponse reports how the Resources were created in the system.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param resource: The created Resource.

#   ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        resource=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.resource = resource
#   meta
#   rate_limit
#   resource
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'resource': self.resource,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            resource=d.get('resource'),
        )
#   class ResourceDeleteResponse:
View Source
class ResourceDeleteResponse:
    """ResourceDeleteResponse returns information about a Resource that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.ResourceDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

ResourceDeleteResponse returns information about a Resource that was deleted.

:param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   ResourceDeleteResponse(meta=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class ResourceGetResponse:
View Source
class ResourceGetResponse:
    """ResourceGetResponse returns a requested Resource.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param resource: The requested Resource.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'resource',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        resource=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.resource = resource
    def __repr__(self):
        return '<sdm.ResourceGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'resource: ' + repr(self.resource) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'resource': self.resource,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            resource=d.get('resource'),
        )

ResourceGetResponse returns a requested Resource.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param resource: The requested Resource.

#   ResourceGetResponse(meta=None, rate_limit=None, resource=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        resource=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.resource = resource
#   meta
#   rate_limit
#   resource
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'resource': self.resource,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            resource=d.get('resource'),
        )
#   class ResourceUpdateResponse:
View Source
class ResourceUpdateResponse:
    """ResourceUpdateResponse returns the fields of a Resource after it has been updated by
 a ResourceUpdateRequest.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param resource: The updated Resource.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'resource',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        resource=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.resource = resource
    def __repr__(self):
        return '<sdm.ResourceUpdateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'resource: ' + repr(self.resource) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'resource': self.resource,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            resource=d.get('resource'),
        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param resource: The updated Resource.

#   ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        resource=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.resource = resource
#   meta
#   rate_limit
#   resource
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'resource': self.resource,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            resource=d.get('resource'),
        )
#   class Role:
View Source
class Role:
    """A Role is a collection of access grants, and typically corresponds to a team, Active Directory OU, or other organizational unit. Users are granted access to resources by assigning them to roles.

    :param access_rules: AccessRules is a list of access rules defining the resources this Role has access to.
    :param composite: Composite is true if the Role is a composite role.

 Deprecated: composite roles are deprecated, use multi-role instead.
    :param id: Unique identifier of the Role.
    :param name: Unique human-readable name of the Role.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'access_rules',
        'composite',
        'id',
        'name',
        'tags',
    ]
    def __init__(self,
        access_rules=None,
        composite=None,
        id=None,
        name=None,
        tags=None,
    ):
        self.access_rules = access_rules
        self.composite = composite
        self.id = id
        self.name = name
        self.tags = tags
    def __repr__(self):
        return '<sdm.Role ' + \
            'access_rules: ' + repr(self.access_rules) + ' ' +\
            'composite: ' + repr(self.composite) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'access_rules': self.access_rules,
            'composite': self.composite,
            'id': self.id,
            'name': self.name,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_rules=d.get('access_rules'),
            composite=d.get('composite'),
            id=d.get('id'),
            name=d.get('name'),
            tags=d.get('tags'),
        )

A Role is a collection of access grants, and typically corresponds to a team, Active Directory OU, or other organizational unit. Users are granted access to resources by assigning them to roles.

:param access_rules: AccessRules is a list of access rules defining the resources this Role has access to. :param composite: Composite is true if the Role is a composite role.

Deprecated: composite roles are deprecated, use multi-role instead. :param id: Unique identifier of the Role. :param name: Unique human-readable name of the Role. :param tags: Tags is a map of key, value pairs.

#   Role(access_rules=None, composite=None, id=None, name=None, tags=None)
View Source
    def __init__(self,
        access_rules=None,
        composite=None,
        id=None,
        name=None,
        tags=None,
    ):
        self.access_rules = access_rules
        self.composite = composite
        self.id = id
        self.name = name
        self.tags = tags
#   access_rules
#   composite
#   id
#   name
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'access_rules': self.access_rules,
            'composite': self.composite,
            'id': self.id,
            'name': self.name,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            access_rules=d.get('access_rules'),
            composite=d.get('composite'),
            id=d.get('id'),
            name=d.get('name'),
            tags=d.get('tags'),
        )
#   class RoleAttachment:
View Source
class RoleAttachment:
    """A RoleAttachment assigns a role to a composite role.
 
 Deprecated: use multi-role instead.

    :param attached_role_id: The id of the attached role of this RoleAttachment.
    :param composite_role_id: The id of the composite role of this RoleAttachment.
    :param id: Unique identifier of the RoleAttachment.
    """
    __slots__ = [
        'attached_role_id',
        'composite_role_id',
        'id',
    ]
    def __init__(self,
        attached_role_id=None,
        composite_role_id=None,
        id=None,
    ):
        self.attached_role_id = attached_role_id
        self.composite_role_id = composite_role_id
        self.id = id
    def __repr__(self):
        return '<sdm.RoleAttachment ' + \
            'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\
            'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'attached_role_id': self.attached_role_id,
            'composite_role_id': self.composite_role_id,
            'id': self.id,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            attached_role_id=d.get('attached_role_id'),
            composite_role_id=d.get('composite_role_id'),
            id=d.get('id'),
        )

A RoleAttachment assigns a role to a composite role.

Deprecated: use multi-role instead.

:param attached_role_id: The id of the attached role of this RoleAttachment. :param composite_role_id: The id of the composite role of this RoleAttachment. :param id: Unique identifier of the RoleAttachment.

#   RoleAttachment(attached_role_id=None, composite_role_id=None, id=None)
View Source
    def __init__(self,
        attached_role_id=None,
        composite_role_id=None,
        id=None,
    ):
        self.attached_role_id = attached_role_id
        self.composite_role_id = composite_role_id
        self.id = id
#   attached_role_id
#   composite_role_id
#   id
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'attached_role_id': self.attached_role_id,
            'composite_role_id': self.composite_role_id,
            'id': self.id,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            attached_role_id=d.get('attached_role_id'),
            composite_role_id=d.get('composite_role_id'),
            id=d.get('id'),
        )
#   class RoleAttachmentCreateResponse:
View Source
class RoleAttachmentCreateResponse:
    """RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.
 
 Deprecated: use multi-role instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role_attachment: The created RoleAttachment.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role_attachment',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_attachment=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_attachment = role_attachment
    def __repr__(self):
        return '<sdm.RoleAttachmentCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_attachment': self.role_attachment,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_attachment=d.get('role_attachment'),
        )

RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.

Deprecated: use multi-role instead.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param role_attachment: The created RoleAttachment.

#   RoleAttachmentCreateResponse(meta=None, rate_limit=None, role_attachment=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_attachment=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_attachment = role_attachment
#   meta
#   rate_limit
#   role_attachment
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_attachment': self.role_attachment,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_attachment=d.get('role_attachment'),
        )
#   class RoleAttachmentDeleteResponse:
View Source
class RoleAttachmentDeleteResponse:
    """RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.
 
 Deprecated: use multi-role instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.RoleAttachmentDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.

Deprecated: use multi-role instead.

:param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   RoleAttachmentDeleteResponse(meta=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class RoleAttachmentGetResponse:
View Source
class RoleAttachmentGetResponse:
    """RoleAttachmentGetResponse returns a requested RoleAttachment.
 
 Deprecated: use multi-role instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role_attachment: The requested RoleAttachment.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role_attachment',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_attachment=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_attachment = role_attachment
    def __repr__(self):
        return '<sdm.RoleAttachmentGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_attachment': self.role_attachment,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_attachment=d.get('role_attachment'),
        )

RoleAttachmentGetResponse returns a requested RoleAttachment.

Deprecated: use multi-role instead.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param role_attachment: The requested RoleAttachment.

#   RoleAttachmentGetResponse(meta=None, rate_limit=None, role_attachment=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_attachment=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_attachment = role_attachment
#   meta
#   rate_limit
#   role_attachment
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_attachment': self.role_attachment,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_attachment=d.get('role_attachment'),
        )
#   class RoleCreateResponse:
View Source
class RoleCreateResponse:
    """RoleCreateResponse reports how the Roles were created in the system. It can
 communicate partial successes or failures.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role: The created Role.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role = role
    def __repr__(self):
        return '<sdm.RoleCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role: ' + repr(self.role) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role': self.role,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role=d.get('role'),
        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param role: The created Role.

#   RoleCreateResponse(meta=None, rate_limit=None, role=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        role=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role = role
#   meta
#   rate_limit
#   role
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role': self.role,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role=d.get('role'),
        )
#   class RoleDeleteResponse:
View Source
class RoleDeleteResponse:
    """RoleDeleteResponse returns information about a Role that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.RoleDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

RoleDeleteResponse returns information about a Role that was deleted.

:param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   RoleDeleteResponse(meta=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class RoleGetResponse:
View Source
class RoleGetResponse:
    """RoleGetResponse returns a requested Role.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role: The requested Role.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role = role
    def __repr__(self):
        return '<sdm.RoleGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role: ' + repr(self.role) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role': self.role,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role=d.get('role'),
        )

RoleGetResponse returns a requested Role.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param role: The requested Role.

#   RoleGetResponse(meta=None, rate_limit=None, role=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        role=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role = role
#   meta
#   rate_limit
#   role
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role': self.role,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role=d.get('role'),
        )
#   class RoleGrant:
View Source
class RoleGrant:
    """A RoleGrant connects a resource to a role, granting members of the role access to that resource.

 Deprecated: use access rules instead.

    :param id: Unique identifier of the RoleGrant.
    :param resource_id: The id of the resource of this RoleGrant.
    :param role_id: The id of the attached role of this RoleGrant.
    """
    __slots__ = [
        'id',
        'resource_id',
        'role_id',
    ]
    def __init__(self,
        id=None,
        resource_id=None,
        role_id=None,
    ):
        self.id = id
        self.resource_id = resource_id
        self.role_id = role_id
    def __repr__(self):
        return '<sdm.RoleGrant ' + \
            'id: ' + repr(self.id) + ' ' +\
            'resource_id: ' + repr(self.resource_id) + ' ' +\
            'role_id: ' + repr(self.role_id) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'id': self.id,
            'resource_id': self.resource_id,
            'role_id': self.role_id,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            resource_id=d.get('resource_id'),
            role_id=d.get('role_id'),
        )

A RoleGrant connects a resource to a role, granting members of the role access to that resource.

Deprecated: use access rules instead.

:param id: Unique identifier of the RoleGrant. :param resource_id: The id of the resource of this RoleGrant. :param role_id: The id of the attached role of this RoleGrant.

#   RoleGrant(id=None, resource_id=None, role_id=None)
View Source
    def __init__(self,
        id=None,
        resource_id=None,
        role_id=None,
    ):
        self.id = id
        self.resource_id = resource_id
        self.role_id = role_id
#   id
#   resource_id
#   role_id
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'id': self.id,
            'resource_id': self.resource_id,
            'role_id': self.role_id,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            resource_id=d.get('resource_id'),
            role_id=d.get('role_id'),
        )
#   class RoleGrantCreateResponse:
View Source
class RoleGrantCreateResponse:
    """RoleGrantCreateResponse reports how the RoleGrants were created in the system.

 Deprecated: use access rules instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role_grant: The created RoleGrant.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role_grant',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_grant=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_grant = role_grant
    def __repr__(self):
        return '<sdm.RoleGrantCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role_grant: ' + repr(self.role_grant) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_grant': self.role_grant,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_grant=d.get('role_grant'),
        )

RoleGrantCreateResponse reports how the RoleGrants were created in the system.

Deprecated: use access rules instead.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param role_grant: The created RoleGrant.

#   RoleGrantCreateResponse(meta=None, rate_limit=None, role_grant=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_grant=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_grant = role_grant
#   meta
#   rate_limit
#   role_grant
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_grant': self.role_grant,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_grant=d.get('role_grant'),
        )
#   class RoleGrantDeleteResponse:
View Source
class RoleGrantDeleteResponse:
    """RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.

 Deprecated: use access rules instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.RoleGrantDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.

Deprecated: use access rules instead.

:param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   RoleGrantDeleteResponse(meta=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class RoleGrantGetResponse:
View Source
class RoleGrantGetResponse:
    """RoleGrantGetResponse returns a requested RoleGrant.

 Deprecated: use access rules instead.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role_grant: The requested RoleGrant.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role_grant',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_grant=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_grant = role_grant
    def __repr__(self):
        return '<sdm.RoleGrantGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role_grant: ' + repr(self.role_grant) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_grant': self.role_grant,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_grant=d.get('role_grant'),
        )

RoleGrantGetResponse returns a requested RoleGrant.

Deprecated: use access rules instead.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param role_grant: The requested RoleGrant.

#   RoleGrantGetResponse(meta=None, rate_limit=None, role_grant=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        role_grant=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role_grant = role_grant
#   meta
#   rate_limit
#   role_grant
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role_grant': self.role_grant,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role_grant=d.get('role_grant'),
        )
#   class RoleUpdateResponse:
View Source
class RoleUpdateResponse:
    """RoleUpdateResponse returns the fields of a Role after it has been updated by
 a RoleUpdateRequest.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param role: The updated Role.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'role',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        role=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role = role
    def __repr__(self):
        return '<sdm.RoleUpdateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'role: ' + repr(self.role) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role': self.role,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role=d.get('role'),
        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param role: The updated Role.

#   RoleUpdateResponse(meta=None, rate_limit=None, role=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        role=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.role = role
#   meta
#   rate_limit
#   role
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'role': self.role,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            role=d.get('role'),
        )
#   class SQLServer:
View Source
class SQLServer:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param override_database: 
    :param password: 
    :param port: 
    :param port_override: 
    :param schema: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'override_database',
        'password',
        'port',
        'port_override',
        'schema',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        schema=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.schema = schema
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SQLServer ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'override_database: ' + repr(self.override_database) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'schema: ' + repr(self.schema) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'schema': self.schema,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            schema=d.get('schema'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param override_database: :param password: :param port: :param port_override: :param schema: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   SQLServer( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        override_database=None,
        password=None,
        port=None,
        port_override=None,
        schema=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.override_database = override_database
        self.password = password
        self.port = port
        self.port_override = port_override
        self.schema = schema
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   override_database
#   password
#   port
#   port_override
#   schema
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'override_database': self.override_database,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'schema': self.schema,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            override_database=d.get('override_database'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            schema=d.get('schema'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class SSH:
View Source
class SSH:
    """

    :param allow_deprecated_key_exchanges: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_forwarding: 
    :param public_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'allow_deprecated_key_exchanges',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'port_forwarding',
        'public_key',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        allow_deprecated_key_exchanges=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_forwarding=None,
        public_key=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_forwarding = port_forwarding
        self.public_key = public_key
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SSH ' + \
            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
            'public_key: ' + repr(self.public_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'allow_deprecated_key_exchanges': self.allow_deprecated_key_exchanges,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_forwarding': self.port_forwarding,
            'public_key': self.public_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            allow_deprecated_key_exchanges=d.get('allow_deprecated_key_exchanges'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_forwarding=d.get('port_forwarding'),
            public_key=d.get('public_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param allow_deprecated_key_exchanges: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param port_forwarding: :param public_key: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   SSH( allow_deprecated_key_exchanges=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, public_key=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        allow_deprecated_key_exchanges=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_forwarding=None,
        public_key=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_forwarding = port_forwarding
        self.public_key = public_key
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   allow_deprecated_key_exchanges
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   port
#   port_forwarding
#   public_key
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'allow_deprecated_key_exchanges': self.allow_deprecated_key_exchanges,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_forwarding': self.port_forwarding,
            'public_key': self.public_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            allow_deprecated_key_exchanges=d.get('allow_deprecated_key_exchanges'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_forwarding=d.get('port_forwarding'),
            public_key=d.get('public_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class SSHCert:
View Source
class SSHCert:
    """

    :param allow_deprecated_key_exchanges: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_forwarding: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'allow_deprecated_key_exchanges',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'port_forwarding',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        allow_deprecated_key_exchanges=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_forwarding=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_forwarding = port_forwarding
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SSHCert ' + \
            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'allow_deprecated_key_exchanges': self.allow_deprecated_key_exchanges,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_forwarding': self.port_forwarding,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            allow_deprecated_key_exchanges=d.get('allow_deprecated_key_exchanges'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_forwarding=d.get('port_forwarding'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param allow_deprecated_key_exchanges: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param port_forwarding: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   SSHCert( allow_deprecated_key_exchanges=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        allow_deprecated_key_exchanges=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_forwarding=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_forwarding = port_forwarding
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   allow_deprecated_key_exchanges
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   port
#   port_forwarding
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'allow_deprecated_key_exchanges': self.allow_deprecated_key_exchanges,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_forwarding': self.port_forwarding,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            allow_deprecated_key_exchanges=d.get('allow_deprecated_key_exchanges'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_forwarding=d.get('port_forwarding'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class SSHCustomerKey:
View Source
class SSHCustomerKey:
    """

    :param allow_deprecated_key_exchanges: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param port: 
    :param port_forwarding: 
    :param private_key: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'allow_deprecated_key_exchanges',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'port',
        'port_forwarding',
        'private_key',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        allow_deprecated_key_exchanges=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_forwarding=None,
        private_key=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_forwarding = port_forwarding
        self.private_key = private_key
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SSHCustomerKey ' + \
            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
            'private_key: ' + repr(self.private_key) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'allow_deprecated_key_exchanges': self.allow_deprecated_key_exchanges,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_forwarding': self.port_forwarding,
            'private_key': self.private_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            allow_deprecated_key_exchanges=d.get('allow_deprecated_key_exchanges'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_forwarding=d.get('port_forwarding'),
            private_key=d.get('private_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param allow_deprecated_key_exchanges: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param port: :param port_forwarding: :param private_key: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   SSHCustomerKey( allow_deprecated_key_exchanges=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, private_key=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        allow_deprecated_key_exchanges=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        port=None,
        port_forwarding=None,
        private_key=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.port = port
        self.port_forwarding = port_forwarding
        self.private_key = private_key
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   allow_deprecated_key_exchanges
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   port
#   port_forwarding
#   private_key
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'allow_deprecated_key_exchanges': self.allow_deprecated_key_exchanges,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'port': self.port,
            'port_forwarding': self.port_forwarding,
            'private_key': self.private_key,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            allow_deprecated_key_exchanges=d.get('allow_deprecated_key_exchanges'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            port=d.get('port'),
            port_forwarding=d.get('port_forwarding'),
            private_key=d.get('private_key'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class SecretStoreCreateResponse:
View Source
class SecretStoreCreateResponse:
    """SecretStoreCreateResponse reports how the SecretStores were created in the system.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param secret_store: The created SecretStore.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'secret_store',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        secret_store=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.secret_store = secret_store
    def __repr__(self):
        return '<sdm.SecretStoreCreateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'secret_store: ' + repr(self.secret_store) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'secret_store': self.secret_store,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            secret_store=d.get('secret_store'),
        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param secret_store: The created SecretStore.

#   SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        secret_store=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.secret_store = secret_store
#   meta
#   rate_limit
#   secret_store
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'secret_store': self.secret_store,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            secret_store=d.get('secret_store'),
        )
#   class SecretStoreDeleteResponse:
View Source
class SecretStoreDeleteResponse:
    """SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    """
    __slots__ = [
        'meta',
        'rate_limit',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
    def __repr__(self):
        return '<sdm.SecretStoreDeleteResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

:param meta: Reserved for future use. :param rate_limit: Rate limit information.

#   SecretStoreDeleteResponse(meta=None, rate_limit=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
#   meta
#   rate_limit
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
        )
#   class SecretStoreGetResponse:
View Source
class SecretStoreGetResponse:
    """SecretStoreGetResponse returns a requested SecretStore.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param secret_store: The requested SecretStore.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'secret_store',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        secret_store=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.secret_store = secret_store
    def __repr__(self):
        return '<sdm.SecretStoreGetResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'secret_store: ' + repr(self.secret_store) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'secret_store': self.secret_store,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            secret_store=d.get('secret_store'),
        )

SecretStoreGetResponse returns a requested SecretStore.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param secret_store: The requested SecretStore.

#   SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        secret_store=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.secret_store = secret_store
#   meta
#   rate_limit
#   secret_store
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'secret_store': self.secret_store,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            secret_store=d.get('secret_store'),
        )
#   class SecretStoreUpdateResponse:
View Source
class SecretStoreUpdateResponse:
    """SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
 a SecretStoreUpdateRequest.

    :param meta: Reserved for future use.
    :param rate_limit: Rate limit information.
    :param secret_store: The updated SecretStore.
    """
    __slots__ = [
        'meta',
        'rate_limit',
        'secret_store',
    ]
    def __init__(self,
        meta=None,
        rate_limit=None,
        secret_store=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.secret_store = secret_store
    def __repr__(self):
        return '<sdm.SecretStoreUpdateResponse ' + \
            'meta: ' + repr(self.meta) + ' ' +\
            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
            'secret_store: ' + repr(self.secret_store) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'secret_store': self.secret_store,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            secret_store=d.get('secret_store'),
        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

:param meta: Reserved for future use. :param rate_limit: Rate limit information. :param secret_store: The updated SecretStore.

#   SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
View Source
    def __init__(self,
        meta=None,
        rate_limit=None,
        secret_store=None,
    ):
        self.meta = meta
        self.rate_limit = rate_limit
        self.secret_store = secret_store
#   meta
#   rate_limit
#   secret_store
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'meta': self.meta,
            'rate_limit': self.rate_limit,
            'secret_store': self.secret_store,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            meta=d.get('meta'),
            rate_limit=d.get('rate_limit'),
            secret_store=d.get('secret_store'),
        )
#   class Service:
View Source
class Service:
    """A Service is a service account that can connect to resources they are granted
 directly, or granted via roles. Services are typically automated jobs.

    :param id: Unique identifier of the Service.
    :param name: Unique human-readable name of the Service.
    :param suspended: The Service's suspended state.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'id',
        'name',
        'suspended',
        'tags',
    ]
    def __init__(self,
        id=None,
        name=None,
        suspended=None,
        tags=None,
    ):
        self.id = id
        self.name = name
        self.suspended = suspended
        self.tags = tags
    def __repr__(self):
        return '<sdm.Service ' + \
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'suspended: ' + repr(self.suspended) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'suspended': self.suspended,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            suspended=d.get('suspended'),
            tags=d.get('tags'),
        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

:param id: Unique identifier of the Service. :param name: Unique human-readable name of the Service. :param suspended: The Service's suspended state. :param tags: Tags is a map of key, value pairs.

#   Service(id=None, name=None, suspended=None, tags=None)
View Source
    def __init__(self,
        id=None,
        name=None,
        suspended=None,
        tags=None,
    ):
        self.id = id
        self.name = name
        self.suspended = suspended
        self.tags = tags
#   id
#   name
#   suspended
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'suspended': self.suspended,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            suspended=d.get('suspended'),
            tags=d.get('tags'),
        )
#   class SingleStore:
View Source
class SingleStore:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SingleStore ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   SingleStore( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Snowflake:
View Source
class Snowflake:
    """

    :param database: 
    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port_override: 
    :param schema: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'database',
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port_override',
        'schema',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port_override=None,
        schema=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port_override = port_override
        self.schema = schema
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Snowflake ' + \
            'database: ' + repr(self.database) + ' ' +\
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'schema: ' + repr(self.schema) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port_override': self.port_override,
            'schema': self.schema,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port_override=d.get('port_override'),
            schema=d.get('schema'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param database: :param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port_override: :param schema: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Snowflake( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        database=None,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port_override=None,
        schema=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.database = database
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port_override = port_override
        self.schema = schema
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   database
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port_override
#   schema
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'database': self.database,
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port_override': self.port_override,
            'schema': self.schema,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            database=d.get('database'),
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port_override=d.get('port_override'),
            schema=d.get('schema'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Sybase:
View Source
class Sybase:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Sybase ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Sybase( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class SybaseIQ:
View Source
class SybaseIQ:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.SybaseIQ ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   SybaseIQ( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class Tag:
View Source
class Tag:
    """

    :param name: 
    :param value: 
    """
    __slots__ = [
        'name',
        'value',
    ]
    def __init__(self,
        name=None,
        value=None,
    ):
        self.name = name
        self.value = value
    def __repr__(self):
        return '<sdm.Tag ' + \
            'name: ' + repr(self.name) + ' ' +\
            'value: ' + repr(self.value) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'name': self.name,
            'value': self.value,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            name=d.get('name'),
            value=d.get('value'),
        )

:param name: :param value:

#   Tag(name=None, value=None)
View Source
    def __init__(self,
        name=None,
        value=None,
    ):
        self.name = name
        self.value = value
#   name
#   value
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'name': self.name,
            'value': self.value,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            name=d.get('name'),
            value=d.get('value'),
        )
#   class Teradata:
View Source
class Teradata:
    """

    :param egress_filter: A filter applied to the routing logic to pin datasource to nodes.
    :param healthy: True if the datasource is reachable and the credentials are valid.
    :param hostname: 
    :param id: Unique identifier of the Resource.
    :param name: Unique human-readable name of the Resource.
    :param password: 
    :param port: 
    :param port_override: 
    :param secret_store_id: ID of the secret store containing credentials for this resource, if any.
    :param tags: Tags is a map of key, value pairs.
    :param username: 
    """
    __slots__ = [
        'egress_filter',
        'healthy',
        'hostname',
        'id',
        'name',
        'password',
        'port',
        'port_override',
        'secret_store_id',
        'tags',
        'username',
    ]
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
    def __repr__(self):
        return '<sdm.Teradata ' + \
            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
            'healthy: ' + repr(self.healthy) + ' ' +\
            'hostname: ' + repr(self.hostname) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'password: ' + repr(self.password) + ' ' +\
            'port: ' + repr(self.port) + ' ' +\
            'port_override: ' + repr(self.port_override) + ' ' +\
            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            'username: ' + repr(self.username) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )

:param egress_filter: A filter applied to the routing logic to pin datasource to nodes. :param healthy: True if the datasource is reachable and the credentials are valid. :param hostname: :param id: Unique identifier of the Resource. :param name: Unique human-readable name of the Resource. :param password: :param port: :param port_override: :param secret_store_id: ID of the secret store containing credentials for this resource, if any. :param tags: Tags is a map of key, value pairs. :param username:

#   Teradata( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
    def __init__(self,
        egress_filter=None,
        healthy=None,
        hostname=None,
        id=None,
        name=None,
        password=None,
        port=None,
        port_override=None,
        secret_store_id=None,
        tags=None,
        username=None,
    ):
        self.egress_filter = egress_filter
        self.healthy = healthy
        self.hostname = hostname
        self.id = id
        self.name = name
        self.password = password
        self.port = port
        self.port_override = port_override
        self.secret_store_id = secret_store_id
        self.tags = tags
        self.username = username
#   egress_filter
#   healthy
#   hostname
#   id
#   name
#   password
#   port
#   port_override
#   secret_store_id
#   tags
#   username
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'egress_filter': self.egress_filter,
            'healthy': self.healthy,
            'hostname': self.hostname,
            'id': self.id,
            'name': self.name,
            'password': self.password,
            'port': self.port,
            'port_override': self.port_override,
            'secret_store_id': self.secret_store_id,
            'tags': self.tags,
            'username': self.username,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            egress_filter=d.get('egress_filter'),
            healthy=d.get('healthy'),
            hostname=d.get('hostname'),
            id=d.get('id'),
            name=d.get('name'),
            password=d.get('password'),
            port=d.get('port'),
            port_override=d.get('port_override'),
            secret_store_id=d.get('secret_store_id'),
            tags=d.get('tags'),
            username=d.get('username'),
        )
#   class UpdateResponseMetadata:
View Source
class UpdateResponseMetadata:
    """UpdateResponseMetadata is reserved for future use."""
    __slots__ = [
    ]
    def __init__(self,
    ):
        pass
    def __repr__(self):
        return '<sdm.UpdateResponseMetadata ' + \
            '>'
    def to_dict(self):
        return {
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
        )

UpdateResponseMetadata is reserved for future use.

#   UpdateResponseMetadata()
View Source
    def __init__(self,
    ):
        pass
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
        )
#   class User:
View Source
class User:
    """A User can connect to resources they are granted directly, or granted
 via roles.

    :param email: The User's email address. Must be unique.
    :param first_name: The User's first name.
    :param id: Unique identifier of the User.
    :param last_name: The User's last name.
    :param suspended: The User's suspended state.
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'email',
        'first_name',
        'id',
        'last_name',
        'suspended',
        'tags',
    ]
    def __init__(self,
        email=None,
        first_name=None,
        id=None,
        last_name=None,
        suspended=None,
        tags=None,
    ):
        self.email = email
        self.first_name = first_name
        self.id = id
        self.last_name = last_name
        self.suspended = suspended
        self.tags = tags
    def __repr__(self):
        return '<sdm.User ' + \
            'email: ' + repr(self.email) + ' ' +\
            'first_name: ' + repr(self.first_name) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'last_name: ' + repr(self.last_name) + ' ' +\
            'suspended: ' + repr(self.suspended) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'email': self.email,
            'first_name': self.first_name,
            'id': self.id,
            'last_name': self.last_name,
            'suspended': self.suspended,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            email=d.get('email'),
            first_name=d.get('first_name'),
            id=d.get('id'),
            last_name=d.get('last_name'),
            suspended=d.get('suspended'),
            tags=d.get('tags'),
        )

A User can connect to resources they are granted directly, or granted via roles.

:param email: The User's email address. Must be unique. :param first_name: The User's first name. :param id: Unique identifier of the User. :param last_name: The User's last name. :param suspended: The User's suspended state. :param tags: Tags is a map of key, value pairs.

#   User( email=None, first_name=None, id=None, last_name=None, suspended=None, tags=None )
View Source
    def __init__(self,
        email=None,
        first_name=None,
        id=None,
        last_name=None,
        suspended=None,
        tags=None,
    ):
        self.email = email
        self.first_name = first_name
        self.id = id
        self.last_name = last_name
        self.suspended = suspended
        self.tags = tags
#   email
#   first_name
#   id
#   last_name
#   suspended
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'email': self.email,
            'first_name': self.first_name,
            'id': self.id,
            'last_name': self.last_name,
            'suspended': self.suspended,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            email=d.get('email'),
            first_name=d.get('first_name'),
            id=d.get('id'),
            last_name=d.get('last_name'),
            suspended=d.get('suspended'),
            tags=d.get('tags'),
        )
#   class VaultTLSStore:
View Source
class VaultTLSStore:
    """

    :param ca_cert_path: 
    :param client_cert_path: 
    :param client_key_path: 
    :param id: Unique identifier of the SecretStore.
    :param name: Unique human-readable name of the SecretStore.
    :param namespace: 
    :param server_address: 
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'ca_cert_path',
        'client_cert_path',
        'client_key_path',
        'id',
        'name',
        'namespace',
        'server_address',
        'tags',
    ]
    def __init__(self,
        ca_cert_path=None,
        client_cert_path=None,
        client_key_path=None,
        id=None,
        name=None,
        namespace=None,
        server_address=None,
        tags=None,
    ):
        self.ca_cert_path = ca_cert_path
        self.client_cert_path = client_cert_path
        self.client_key_path = client_key_path
        self.id = id
        self.name = name
        self.namespace = namespace
        self.server_address = server_address
        self.tags = tags
    def __repr__(self):
        return '<sdm.VaultTLSStore ' + \
            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'namespace: ' + repr(self.namespace) + ' ' +\
            'server_address: ' + repr(self.server_address) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'ca_cert_path': self.ca_cert_path,
            'client_cert_path': self.client_cert_path,
            'client_key_path': self.client_key_path,
            'id': self.id,
            'name': self.name,
            'namespace': self.namespace,
            'server_address': self.server_address,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            ca_cert_path=d.get('ca_cert_path'),
            client_cert_path=d.get('client_cert_path'),
            client_key_path=d.get('client_key_path'),
            id=d.get('id'),
            name=d.get('name'),
            namespace=d.get('namespace'),
            server_address=d.get('server_address'),
            tags=d.get('tags'),
        )

:param ca_cert_path: :param client_cert_path: :param client_key_path: :param id: Unique identifier of the SecretStore. :param name: Unique human-readable name of the SecretStore. :param namespace: :param server_address: :param tags: Tags is a map of key, value pairs.

#   VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None )
View Source
    def __init__(self,
        ca_cert_path=None,
        client_cert_path=None,
        client_key_path=None,
        id=None,
        name=None,
        namespace=None,
        server_address=None,
        tags=None,
    ):
        self.ca_cert_path = ca_cert_path
        self.client_cert_path = client_cert_path
        self.client_key_path = client_key_path
        self.id = id
        self.name = name
        self.namespace = namespace
        self.server_address = server_address
        self.tags = tags
#   ca_cert_path
#   client_cert_path
#   client_key_path
#   id
#   name
#   namespace
#   server_address
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'ca_cert_path': self.ca_cert_path,
            'client_cert_path': self.client_cert_path,
            'client_key_path': self.client_key_path,
            'id': self.id,
            'name': self.name,
            'namespace': self.namespace,
            'server_address': self.server_address,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            ca_cert_path=d.get('ca_cert_path'),
            client_cert_path=d.get('client_cert_path'),
            client_key_path=d.get('client_key_path'),
            id=d.get('id'),
            name=d.get('name'),
            namespace=d.get('namespace'),
            server_address=d.get('server_address'),
            tags=d.get('tags'),
        )
#   class VaultTokenStore:
View Source
class VaultTokenStore:
    """

    :param id: Unique identifier of the SecretStore.
    :param name: Unique human-readable name of the SecretStore.
    :param namespace: 
    :param server_address: 
    :param tags: Tags is a map of key, value pairs.
    """
    __slots__ = [
        'id',
        'name',
        'namespace',
        'server_address',
        'tags',
    ]
    def __init__(self,
        id=None,
        name=None,
        namespace=None,
        server_address=None,
        tags=None,
    ):
        self.id = id
        self.name = name
        self.namespace = namespace
        self.server_address = server_address
        self.tags = tags
    def __repr__(self):
        return '<sdm.VaultTokenStore ' + \
            'id: ' + repr(self.id) + ' ' +\
            'name: ' + repr(self.name) + ' ' +\
            'namespace: ' + repr(self.namespace) + ' ' +\
            'server_address: ' + repr(self.server_address) + ' ' +\
            'tags: ' + repr(self.tags) + ' ' +\
            '>'
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'namespace': self.namespace,
            'server_address': self.server_address,
            'tags': self.tags,
        }
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            namespace=d.get('namespace'),
            server_address=d.get('server_address'),
            tags=d.get('tags'),
        )

:param id: Unique identifier of the SecretStore. :param name: Unique human-readable name of the SecretStore. :param namespace: :param server_address: :param tags: Tags is a map of key, value pairs.

#   VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
View Source
    def __init__(self,
        id=None,
        name=None,
        namespace=None,
        server_address=None,
        tags=None,
    ):
        self.id = id
        self.name = name
        self.namespace = namespace
        self.server_address = server_address
        self.tags = tags
#   id
#   name
#   namespace
#   server_address
#   tags
#   def to_dict(self):
View Source
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'namespace': self.namespace,
            'server_address': self.server_address,
            'tags': self.tags,
        }
#  
@classmethod
def from_dict(cls, d):
View Source
    @classmethod
    def from_dict(cls, d):
        return cls(
            id=d.get('id'),
            name=d.get('name'),
            namespace=d.get('namespace'),
            server_address=d.get('server_address'),
            tags=d.get('tags'),
        )